Python Note.set方法代码示例

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
 def create_event(self, description=_("Estimated date"),
                  type=None, date=None, source=None,
                  note_text="", modifier=None):
     event = Event()
     event.set_description(description)
     note = Note()
     note.handle = create_id()
     note.type.set(NoteType.EVENT)
     note.set(note_text)
     self.db.add_note(note, self.trans)
     event.add_note(note.handle)
     if type:
         event.set_type(EventType(type))
     if date:
         if modifier:
             date.set_modifier(modifier)
         date.set_quality(Date.QUAL_ESTIMATED)
         date.set_yr_mon_day(date.get_year(), 0, 0)
         event.set_date_object(date)
     if source:
         citation = Citation()
         citation.set_reference_handle(source.get_handle())
         self.db.add_citation(citation, self.trans)
         event.add_citation(citation.get_handle())
         self.db.commit_source(source, self.trans)
     self.db.add_event(event, self.trans)
     return event

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
 def read_family_comment(self,line,fields):
     if not self.current_family:
         LOG.warning("Unknown family of child in line %d!" % self.lineno)
         return None
     n = Note()
     n.set(line)
     self.db.add_note(n,self.trans)
     self.current_family.add_note(n.handle)
     self.db.commit_family(self.current_family,self.trans)
     return None

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
    def read_pevent_line(self, event, fields):

        name = fields[2] + fields[1]

        try:
            self.person = self.ikeys[name]
        # check key on {ikey}
        except:
            self.person = "(TO_CHECK: %s)" % fields[1:]
            #GrampsImportError()

        lastname = fields[1]
        firstname = fields[2]
        self.current_person = self.get_or_create_person(firstname, lastname)

        #name = Name()
        #name.set_type(NameType(NameType.BIRTH))
        #name.set_first_name(firstname)
        #surname_obj = name.get_primary_surname()
        #surname_obj.set_surname(surname)
        #self.current_person.set_primary_name(name)

        if pevents_map.get(event[0:5]) == None:
            return #need to fix custom event types not in the map

        self.current_event = None
        # get events for the current person
        for evr in self.current_person.get_event_ref_list():
            ev = self.db.get_event_from_handle(evr.get_reference_handle())
            if ev.get_type() == pevents_map.get(event[0:5]):
                self.current_event = ev # found. Need to also check EventRef role
            if not self.current_event: # No event found create a new one
                self.current_event = self.new_gwplus_pevent(event)
        while True:
            line = self.get_next_line()
            if line and line[0:5] in pevents_map:
                self.current_mode = "person_event"
                self.current_event = self.new_gwplus_pevent(line)
            elif line and line[0:4] == "note":
                n = Note()
                n.set(line[5:])
                self.db.add_note(n, self.trans)
                if self.current_event:
                    self.current_event.add_note(n.handle)
                    self.db.commit_event(self.current_event, self.trans)
                else:
                    print('note', n.handle)
            else:
                self.current_mode = None
                #self.db.commit_person(self.current_person,self.trans)
                break

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
    def _read_notes_lines(self, note_tag):
        note_txt = ""
        while True:
            line = self.get_next_line()
            if line is None:
                break

            fields = line.split(" ")
            if fields[0] == "end" and fields[1] == note_tag:
                break
            elif fields[0] == "beg":
                continue
            else:
                if note_txt:
                    note_txt = note_txt + "\n" + line
                else:
                    note_txt = note_txt + line
        if note_txt:
            n = Note()
            n.set(note_txt)
            self.db.add_note(n,self.trans)
            return n.handle
        return None

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
    def parse_person(self,fields,idx,gender,father_surname):

        if not father_surname:
            if not idx < len(fields):
                LOG.warning("Missing surname of person in line %d!" % self.lineno)
                surname =""
            else:
                surname = self.decode(fields[idx])
            idx += 1
        else:
            surname = father_surname

        if not idx < len(fields):
            LOG.warning("Missing firstname of person in line %d!" % self.lineno)
            firstname = ""
        else:
            firstname = self.decode(fields[idx])
        idx += 1
        if idx < len(fields) and father_surname:
            noSurnameRe = re.compile("^[({\[~><?0-9#].*$")
            if not noSurnameRe.match(fields[idx]):
                surname = self.decode(fields[idx])
                idx += 1

        LOG.debug("Person: %s %s" % (firstname, surname))
        person = self.get_or_create_person(firstname,surname)
        name = Name()
        name.set_type( NameType(NameType.BIRTH))
        name.set_first_name(firstname)
        surname_obj = name.get_primary_surname()
        surname_obj.set_surname(surname)
        person.set_primary_name(name)
        if person.get_gender() == Person.UNKNOWN and gender is not None:
            person.set_gender(gender)
        self.db.commit_person(person,self.trans)
        personDataRe = re.compile("^[kmes0-9<>~#\[({!].*$")
        dateRe = re.compile("^[kmes0-9~<>?]+.*$")

        source = None
        birth_parsed = False
        birth_date = None
        birth_place = None
        birth_source = None

        bapt_date = None
        bapt_place = None
        bapt_source = None

        death_date = None
        death_place = None
        death_source = None
        death_cause = None

        crem_date = None
        bur_date = None
        bur_place = None
        bur_source = None

        public_name = None
        firstname_aliases = []
        nick_names = []
        name_aliases = []
        surname_aliases = []

        while idx < len(fields) and personDataRe.match(fields[idx]):
            field = fields[idx]
            idx += 1
            if field.startswith('('):
                LOG.debug("Public Name: %s" % field)
                public_name = self.decode(field[1:-1])
            elif field.startswith('{'):
                LOG.debug("Firstsname Alias: %s" % field)
                firstname_aliases.append(self.decode(field[1:-1]))
            elif field.startswith('['):
                LOG.debug("Title: %s" % field)
                titleparts = self.decode(field[1:-1]).split(":")
                tname = ttitle = tplace = tstart = tend = tnth = None
                try:
                    tname =  titleparts[0]
                    ttitle = titleparts[1]
                    if titleparts[2]:
                        tplace = self.get_or_create_place(titleparts[2])
                    tstart = self.parse_date(titleparts[3])
                    tend =   self.parse_date(titleparts[4])
                    tnth =   titleparts[5]
                except IndexError:  # not all parts are written all the time
                    pass
                if tnth:    # Append title numer to title
                    ttitle += ", " + tnth
                title = self.create_event(
                           EventType.NOB_TITLE, ttitle, tstart, tplace)
                # TODO: Geneweb has a start date and an end date, and therefore
                # supports stuff like: FROM about 1955 TO between 1998 and 1999
                # gramps only supports one single date or range.
                if tname and tname != "*":
                    n = Note()
                    n.set(tname)
                    self.db.add_note(n,self.trans)
                    title.add_note( n.handle)
                title_ref = EventRef()
#.........这里部分代码省略.........

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
 def _parse_person(self, line_number, row, col):
     "Parse the content of a Person line."
     surname   = rd(line_number, row, col, "surname")
     firstname = rd(line_number, row, col, "firstname", "")
     callname  = rd(line_number, row, col, "callname")
     title     = rd(line_number, row, col, "title")
     prefix    = rd(line_number, row, col, "prefix")
     suffix    = rd(line_number, row, col, "suffix")
     gender    = rd(line_number, row, col, "gender")
     source    = rd(line_number, row, col, "source")
     note      = rd(line_number, row, col, "note")
     birthplace  = rd(line_number, row, col, "birthplace")
     birthplace_id  = rd(line_number, row, col, "birthplace_id")
     birthdate   = rd(line_number, row, col, "birthdate")
     birthsource = rd(line_number, row, col, "birthsource")
     baptismplace  = rd(line_number, row, col, "baptismplace")
     baptismplace_id  = rd(line_number, row, col, "baptismplace_id")
     baptismdate   = rd(line_number, row, col, "baptismdate")
     baptismsource = rd(line_number, row, col, "baptismsource")
     burialplace  = rd(line_number, row, col, "burialplace")
     burialplace_id  = rd(line_number, row, col, "burialplace_id")
     burialdate   = rd(line_number, row, col, "burialdate")
     burialsource = rd(line_number, row, col, "burialsource")
     deathplace  = rd(line_number, row, col, "deathplace")
     deathplace_id  = rd(line_number, row, col, "deathplace_id")
     deathdate   = rd(line_number, row, col, "deathdate")
     deathsource = rd(line_number, row, col, "deathsource")
     deathcause  = rd(line_number, row, col, "deathcause")
     grampsid    = rd(line_number, row, col, "grampsid")
     person_ref  = rd(line_number, row, col, "person")
     #########################################################
     # if this person already exists, don't create them
     person = self.lookup("person", person_ref)
     if person is None:
         if surname is None:
             LOG.warn("empty surname for new person on line %d" %
                      line_number)
             surname = ""
         # new person
         person = self.create_person()
         name = Name()
         name.set_type(NameType(NameType.BIRTH))
         name.set_first_name(firstname)
         surname_obj = Surname()
         surname_obj.set_surname(surname)
         name.add_surname(surname_obj)
         person.set_primary_name(name)
     else:
         name = person.get_primary_name()
     #########################################################
     if person_ref is not None:
         self.storeup("person", person_ref, person)
     # replace
     if surname is not None:
         name.get_primary_surname().set_surname(surname)
     if firstname is not None:
         name.set_first_name(firstname)
     if callname is not None:
         name.set_call_name(callname)
     if title is not None:
         name.set_title(title)
     if prefix is not None:
         name.get_primary_surname().set_prefix(prefix)
         name.group_as = '' # HELP? what should I do here?
     if suffix is not None:
         name.set_suffix(suffix)
     if note is not None:
         # append notes, if previous notes
         previous_notes_list = person.get_note_list()
         updated_note = False
         for note_handle in previous_notes_list:
             previous_note = self.db.get_note_from_handle(note_handle)
             if previous_note.type == NoteType.PERSON:
                 previous_text = previous_note.get()
                 if note not in previous_text:
                     note = previous_text + "\n" + note
                 previous_note.set(note)
                 self.db.commit_note(previous_note, self.trans)
                 updated_note = True
                 break
         if not updated_note:
             # add new note here
             new_note = Note()
             new_note.handle = create_id()
             new_note.type.set(NoteType.PERSON)
             new_note.set(note)
             if self.default_tag:
                 new_note.add_tag(self.default_tag.handle)
             self.db.add_note(new_note, self.trans)
             person.add_note(new_note.handle)
     if grampsid is not None:
         person.gramps_id = grampsid
     elif person_ref is not None:
         if person_ref.startswith("[") and person_ref.endswith("]"):
             person.gramps_id = self.db.id2user_format(person_ref[1:-1])
     if (person.get_gender() == Person.UNKNOWN and
             gender is not None):
         gender = gender.lower()
         if gender == gender_map[Person.MALE].lower():
             gender = Person.MALE
#.........这里部分代码省略.........

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
 def _parse_family(self, line_number, row, col):
     "Parse the content of a family line"
     family_ref   = rd(line_number, row, col, "family")
     if family_ref is None:
         LOG.warn("no family reference found for family on line %d" %
                  line_number)
         return # required
     child   = rd(line_number, row, col, "child")
     source  = rd(line_number, row, col, "source")
     note  = rd(line_number, row, col, "note")
     gender  = rd(line_number, row, col, "gender")
     child = self.lookup("person", child)
     family = self.lookup("family", family_ref)
     if family is None:
         LOG.warn("no matching family reference found for family "
                  "on line %d" % line_number)
         return
     if child is None:
         LOG.warn("no matching child reference found for family "
                  "on line %d" % line_number)
         return
     # is this child already in this family? If so, don't add
     LOG.debug("children: %s", [ref.ref for ref in
                                family.get_child_ref_list()])
     LOG.debug("looking for: %s", child.get_handle())
     if child.get_handle() not in [ref.ref for ref in
                                   family.get_child_ref_list()]:
         # add child to family
         LOG.debug("   adding child [%s] to family [%s]",
                   child.get_gramps_id(), family.get_gramps_id())
         childref = ChildRef()
         childref.set_reference_handle(child.get_handle())
         family.add_child_ref( childref)
         self.db.commit_family(family, self.trans)
         child.add_parent_family_handle(family.get_handle())
     if gender:
         # replace
         gender = gender.lower()
         if gender == gender_map[Person.MALE].lower():
             gender = Person.MALE
         elif gender == gender_map[Person.FEMALE].lower():
             gender = Person.FEMALE
         else:
             gender = Person.UNKNOWN
         child.set_gender(gender)
     if source:
         # add, if new
         dummy_new, source = self.get_or_create_source(source)
         self.find_and_set_citation(child, source)
     # put note on child
     if note:
         # append notes, if previous notes
         previous_notes_list = child.get_note_list()
         updated_note = False
         for note_handle in previous_notes_list:
             previous_note = self.db.get_note_from_handle(note_handle)
             if previous_note.type == NoteType.PERSON:
                 previous_text = previous_note.get()
                 if note not in previous_text:
                     note = previous_text + "\n" + note
                 previous_note.set(note)
                 self.db.commit_note(previous_note, self.trans)
                 updated_note = True
                 break
         if not updated_note:
             # add new note here
             new_note = Note()
             new_note.handle = create_id()
             new_note.type.set(NoteType.PERSON)
             new_note.set(note)
             if self.default_tag:
                 new_note.add_tag(self.default_tag.handle)
             self.db.add_note(new_note, self.trans)
             child.add_note(new_note.handle)
     self.db.commit_person(child, self.trans)

# 需要导入模块: from gramps.gen.lib import Note [as 别名]
# 或者: from gramps.gen.lib.Note import set [as 别名]
 def _parse_marriage(self, line_number, row, col):
     "Parse the content of a Marriage,Husband,Wife line."
     marriage_ref   = rd(line_number, row, col, "marriage")
     husband  = rd(line_number, row, col, "husband")
     wife     = rd(line_number, row, col, "wife")
     marriagedate = rd(line_number, row, col, "date")
     marriageplace = rd(line_number, row, col, "place")
     marriageplace_id = rd(line_number, row, col, "place_id")
     marriagesource = rd(line_number, row, col, "source")
     note = rd(line_number, row, col, "note")
     wife = self.lookup("person", wife)
     husband = self.lookup("person", husband)
     if husband is None and wife is None:
         # might have children, so go ahead and add
         LOG.warn("no parents on line %d; adding family anyway" %
                  line_number)
     family = self.get_or_create_family(marriage_ref, husband, wife)
     # adjust gender, if not already provided
     if husband:
         # this is just a guess, if unknown
         if husband.get_gender() == Person.UNKNOWN:
             husband.set_gender(Person.MALE)
             self.db.commit_person(husband, self.trans)
     if wife:
         # this is just a guess, if unknown
         if wife.get_gender() == Person.UNKNOWN:
             wife.set_gender(Person.FEMALE)
             self.db.commit_person(wife, self.trans)
     if marriage_ref:
         self.storeup("family", marriage_ref.lower(), family)
     if marriagesource:
         # add, if new
         new, marriagesource = self.get_or_create_source(marriagesource)
     if marriageplace and marriageplace_id:
         raise Error("Error in marriage: can't have a place and place_id")
     if marriageplace:
         # add, if new
         new, marriageplace = self.get_or_create_place(marriageplace)
     elif marriageplace_id:
         # better exist already, locally or in database:
         marriageplace = self.lookup("place", marriageplace_id)
     if marriagedate:
         marriagedate = _dp.parse(marriagedate)
     if marriagedate or marriageplace or marriagesource or note:
         # add, if new; replace, if different
         new, marriage = self.get_or_create_event(family,
                 EventType.MARRIAGE, marriagedate,
                 marriageplace, marriagesource)
         if new:
             mar_ref = EventRef()
             mar_ref.set_reference_handle(marriage.get_handle())
             family.add_event_ref(mar_ref)
             self.db.commit_family(family, self.trans)
         # only add note to event:
         # append notes, if previous notes
         if note:
             previous_notes_list = marriage.get_note_list()
             updated_note = False
             for note_handle in previous_notes_list:
                 previous_note = self.db.get_note_from_handle(
                         note_handle)
                 if previous_note.type == NoteType.EVENT:
                     previous_text = previous_note.get()
                     if note not in previous_text:
                         note = previous_text + "\n" + note
                     previous_note.set(note)
                     self.db.commit_note(previous_note, self.trans)
                     updated_note = True
                     break
             if not updated_note:
                 # add new note here
                 new_note = Note()
                 new_note.handle = create_id()
                 new_note.type.set(NoteType.EVENT)
                 new_note.set(note)
                 if self.default_tag:
                     new_note.add_tag(self.default_tag.handle)
                 self.db.add_note(new_note, self.trans)
                 marriage.add_note(new_note.handle)
             self.db.commit_event(marriage, self.trans)