From feab448edaffdc4ba587b5005c64aca036c66ecc Mon Sep 17 00:00:00 2001 From: Don Allingham Date: Fri, 2 Mar 2007 05:08:58 +0000 Subject: [PATCH] svn: r8260 --- src/GrampsDbUtils/_GedcomLex.py | 42 +- src/GrampsDbUtils/_GedcomParse.py | 7394 ++++++++++++++--------------- 2 files changed, 3718 insertions(+), 3718 deletions(-) diff --git a/src/GrampsDbUtils/_GedcomLex.py b/src/GrampsDbUtils/_GedcomLex.py index de9e48165..7b5f487d1 100644 --- a/src/GrampsDbUtils/_GedcomLex.py +++ b/src/GrampsDbUtils/_GedcomLex.py @@ -58,21 +58,21 @@ LOG = logging.getLogger(".GedcomImport") #------------------------------------------------------------------------- GED2GRAMPS = {} -for _val in personalConstantEvents.keys(): - _key = personalConstantEvents[_val] - if _key != "": - GED2GRAMPS[_key] = _val +for __val in personalConstantEvents.keys(): + __key = personalConstantEvents[__val] + if __key != "": + GED2GRAMPS[__key] = __val -for _val in familyConstantEvents.keys(): - _key = familyConstantEvents[_val] - if _key != "": - GED2GRAMPS[_key] = _val +for __val in familyConstantEvents.keys(): + __key = familyConstantEvents[__val] + if __key != "": + GED2GRAMPS[__key] = __val GED2ATTR = {} -for _val in personalConstantAttributes.keys(): - _key = personalConstantAttributes[_val] - if _key != "": - GED2ATTR[_key] = _val +for __val in personalConstantAttributes.keys(): + __key = personalConstantAttributes[__val] + if __key != "": + GED2ATTR[__key] = __val #------------------------------------------------------------------------- # @@ -322,40 +322,40 @@ class Reader: self.cnt = 0 self.index = 0 self.func_map = { - TOKEN_CONT : self._fix_token_cont, - TOKEN_CONC : self._fix_token_conc, + TOKEN_CONT : self.__fix_token_cont, + TOKEN_CONC : self.__fix_token_conc, } def set_broken_conc(self, broken): self.func_map = { - TOKEN_CONT : self._fix_token_cont, - TOKEN_CONC : self._fix_token_broken_conc, + TOKEN_CONT : self.__fix_token_cont, +p TOKEN_CONC : self.__fix_token_broken_conc, } def readline(self): if len(self.current_list) <= 1 and not self.eof: - self.readahead() + self.__readahead() try: return GedLine(self.current_list.pop()) except: return None - def _fix_token_cont(self, data): + def __fix_token_cont(self, data): line = self.current_list[0] new_value = line[2]+'\n'+data[2] self.current_list[0] = (line[0], line[1], new_value, line[3], line[4]) - def _fix_token_conc(self, data): + def __fix_token_conc(self, data): line = self.current_list[0] new_value = line[2] + data[2] self.current_list[0] = (line[0], line[1], new_value, line[3], line[4]) - def _fix_token_broken_conc(self, data): + def __fix_token_broken_conc(self, data): line = self.current_list[0] new_value = u"%s %s" % (line[2], data[2]) self.current_list[0] = (line[0], line[1], new_value, line[3], line[4]) - def readahead(self): + def __readahead(self): while len(self.current_list) < 5: line = self.ifile.readline() self.index += 1 diff --git a/src/GrampsDbUtils/_GedcomParse.py b/src/GrampsDbUtils/_GedcomParse.py index dd8090d11..fdde09c72 100644 --- a/src/GrampsDbUtils/_GedcomParse.py +++ b/src/GrampsDbUtils/_GedcomParse.py @@ -10,12 +10,12 @@ # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # $Id: _ReadGedcom.py 8032 2007-02-03 17:11:05Z hippy $ @@ -136,12 +136,12 @@ except: # Address/Place constants # #------------------------------------------------------------------------- -ADDR_RE = re.compile('(.+)([\n\r]+)(.+)\s*,(.+)\s+(\d+)\s*(.*)') +ADDR_RE = re.compile('(.+)([\n\r]+)(.+)\s*,(.+)\s+(\d+)\s*(.*)') ADDR2_RE = re.compile('(.+)([\n\r]+)(.+)\s*,(.+)\s+(\d+)') ADDR3_RE = re.compile('(.+)([\n\r]+)(.+)\s*,(.+)') TRUNC_MSG = _("Your GEDCOM file is corrupted. " - "It appears to have been truncated.") + "It appears to have been truncated.") #------------------------------------------------------------------------- # @@ -187,22 +187,22 @@ FTW_BAD_PLACE = [ ] MEDIA_MAP = { - 'audio' : RelLib.SourceMediaType.AUDIO, - 'book' : RelLib.SourceMediaType.BOOK, - 'card' : RelLib.SourceMediaType.CARD, + 'audio' : RelLib.SourceMediaType.AUDIO, + 'book' : RelLib.SourceMediaType.BOOK, + 'card' : RelLib.SourceMediaType.CARD, 'electronic' : RelLib.SourceMediaType.ELECTRONIC, - 'fiche' : RelLib.SourceMediaType.FICHE, + 'fiche' : RelLib.SourceMediaType.FICHE, 'microfiche' : RelLib.SourceMediaType.FICHE, - 'microfilm' : RelLib.SourceMediaType.FICHE, - 'film' : RelLib.SourceMediaType.FILM, - 'magazine' : RelLib.SourceMediaType.MAGAZINE, + 'microfilm' : RelLib.SourceMediaType.FICHE, + 'film' : RelLib.SourceMediaType.FILM, + 'magazine' : RelLib.SourceMediaType.MAGAZINE, 'manuscript' : RelLib.SourceMediaType.MANUSCRIPT, - 'map' : RelLib.SourceMediaType.MAP, - 'newspaper' : RelLib.SourceMediaType.NEWSPAPER, - 'photo' : RelLib.SourceMediaType.PHOTO, - 'tombstone' : RelLib.SourceMediaType.TOMBSTONE, - 'grave' : RelLib.SourceMediaType.TOMBSTONE, - 'video' : RelLib.SourceMediaType.VIDEO, + 'map' : RelLib.SourceMediaType.MAP, + 'newspaper' : RelLib.SourceMediaType.NEWSPAPER, + 'photo' : RelLib.SourceMediaType.PHOTO, + 'tombstone' : RelLib.SourceMediaType.TOMBSTONE, + 'grave' : RelLib.SourceMediaType.TOMBSTONE, + 'video' : RelLib.SourceMediaType.VIDEO, } #------------------------------------------------------------------------- @@ -214,13 +214,13 @@ GED_2_GRAMPS = {} for _val in personalConstantEvents.keys(): _key = personalConstantEvents[_val] if _key != "": - GED_2_GRAMPS[_key] = _val + GED_2_GRAMPS[_key] = _val GED_2_FAMILY = {} for _val in familyConstantEvents.keys(): _key = familyConstantEvents[_val] if _key != "": - GED_2_FAMILY[_key] = _val + GED_2_FAMILY[_key] = _val GED_2_FAMILY_CUSTOM = {} @@ -229,10 +229,10 @@ GED_2_FAMILY_CUSTOM = {} # regular expressions # #------------------------------------------------------------------------- -INT_RE = re.compile(r"\s*(\d+)\s*$") -NOTE_RE = re.compile(r"\s*\d+\s+\@(\S+)\@\s+NOTE(.*)$") -CONT_RE = re.compile(r"\s*\d+\s+CONT\s?(.*)$") -CONC_RE = re.compile(r"\s*\d+\s+CONC\s?(.*)$") +INT_RE = re.compile(r"\s*(\d+)\s*$") +NOTE_RE = re.compile(r"\s*\d+\s+\@(\S+)\@\s+NOTE(.*)$") +CONT_RE = re.compile(r"\s*\d+\s+CONT\s?(.*)$") +CONC_RE = re.compile(r"\s*\d+\s+CONC\s?(.*)$") PERSON_RE = re.compile(r"\s*\d+\s+\@(\S+)\@\s+INDI(.*)$") class StageOne: @@ -248,35 +248,34 @@ class StageOne: def parse(self): current = "" - line = self.ifile.read(3) - if line == "\xef\xbb": - self.ifile.read(1) - self.enc = "UTF8" - else: - self.ifile.seek(0) + line = self.ifile.read(3) + if line == "\xef\xbb": + self.ifile.read(1) + self.enc = "UTF8" + else: + self.ifile.seek(0) for line in self.ifile: - self.lcnt +=1 + self.lcnt += 1 - data = line.split(None,2) + [''] - try: - (level, key, value) = data[:3] - value = value.strip() - try: - level = int(level) - except: - level = 0 - key = key.strip() - except: - LOG.warn(_("Invalid line %d in GEDCOM file.") % self.lcnt) - #raise Errors.GedcomError("Corrupted file at line %d" % self.lcnt) + data = line.split(None, 2) + [''] + try: + (level, key, value) = data[:3] + value = value.strip() + try: + level = int(level) + except: + level = 0 + key = key.strip() + except: + LOG.warn(_("Invalid line %d in GEDCOM file.") % self.lcnt) if level == 0 and key[0] == '@': - if value == ("FAM", "FAMILY") : - current = key.strip() - current = current[1:-1] - elif value == ("INDI", "INDIVIDUAL"): - self.pcnt += 1 + if value == ("FAM", "FAMILY") : + current = key.strip() + current = current[1:-1] + elif value == ("INDI", "INDIVIDUAL"): + self.pcnt += 1 elif key in ("HUSB", "HUSBAND", "WIFE") and value and value[0] == '@': value = value[1:-1] if self.fams.has_key(value): @@ -325,2088 +324,2088 @@ class GedcomParser(UpdateCallback): BadFile = "Not a GEDCOM file" def __init__(self, dbase, ifile, filename, callback, stage_one): - UpdateCallback.__init__(self, callback) + UpdateCallback.__init__(self, callback) - self.set_total(stage_one.get_line_count()) + self.set_total(stage_one.get_line_count()) - self.repo2id = {} - self.maxpeople = stage_one.get_person_count() - self.dbase = dbase - self.emapper = GedcomUtils.IdFinder(dbase.get_gramps_ids(EVENT_KEY), - dbase.eprefix) + self.repo2id = {} + self.maxpeople = stage_one.get_person_count() + self.dbase = dbase + self.emapper = GedcomUtils.IdFinder(dbase.get_gramps_ids(EVENT_KEY), + dbase.eprefix) self.famc_map = stage_one.get_famc_map() self.fams_map = stage_one.get_fams_map() - self.place_parser = GedcomUtils.PlaceParser() - self.inline_srcs = {} - self.media_map = {} - self.refn = {} - self.added = set() - self.gedmap = GedcomInfoDB() - self.gedsource = self.gedmap.get_from_source_tag('GEDCOM 5.5') - self.use_def_src = DEFAULT_SOURCE - if self.use_def_src: - self.def_src = RelLib.Source() - fname = os.path.basename(filename).split('\\')[-1] - self.def_src.set_title(_("Import from GEDCOM (%s)") % - encode_filename(fname)) - self.dir_path = os.path.dirname(filename) - self.is_ftw = False + self.place_parser = GedcomUtils.PlaceParser() + self.inline_srcs = {} + self.media_map = {} + self.refn = {} + self.added = set() + self.gedmap = GedcomInfoDB() + self.gedsource = self.gedmap.get_from_source_tag('GEDCOM 5.5') + self.use_def_src = DEFAULT_SOURCE + if self.use_def_src: + self.def_src = RelLib.Source() + fname = os.path.basename(filename).split('\\')[-1] + self.def_src.set_title(_("Import from GEDCOM (%s)") % + encode_filename(fname)) + self.dir_path = os.path.dirname(filename) + self.is_ftw = False self.is_ancestry_com = False - self.pid_map = GedcomUtils.IdMapper( - self.dbase.id_trans, - self.dbase.find_next_person_gramps_id, - self.dbase.get_number_of_people()) - self.fid_map = GedcomUtils.IdMapper( - self.dbase.fid_trans, - self.dbase.find_next_family_gramps_id, - self.dbase.get_number_of_families()) - self.sid_map = GedcomUtils.IdMapper( - self.dbase.sid_trans, - self.dbase.find_next_source_gramps_id, - self.dbase.get_number_of_sources()) - self.oid_map = GedcomUtils.IdMapper( - self.dbase.oid_trans, - self.dbase.find_next_object_gramps_id, - self.dbase.get_number_of_media_objects()) - self.rid_map = GedcomUtils.IdMapper( - self.dbase.rid_trans, - self.dbase.find_next_repository_gramps_id, - self.dbase.get_number_of_repositories()) - self.nid_map = GedcomUtils.IdMapper( - self.dbase.nid_trans, - self.dbase.find_next_note_gramps_id, - self.dbase.get_number_of_notes()) + self.pid_map = GedcomUtils.IdMapper( + self.dbase.id_trans, + self.dbase.find_next_person_gramps_id, + self.dbase.get_number_of_people()) + self.fid_map = GedcomUtils.IdMapper( + self.dbase.fid_trans, + self.dbase.find_next_family_gramps_id, + self.dbase.get_number_of_families()) + self.sid_map = GedcomUtils.IdMapper( + self.dbase.sid_trans, + self.dbase.find_next_source_gramps_id, + self.dbase.get_number_of_sources()) + self.oid_map = GedcomUtils.IdMapper( + self.dbase.oid_trans, + self.dbase.find_next_object_gramps_id, + self.dbase.get_number_of_media_objects()) + self.rid_map = GedcomUtils.IdMapper( + self.dbase.rid_trans, + self.dbase.find_next_repository_gramps_id, + self.dbase.get_number_of_repositories()) + self.nid_map = GedcomUtils.IdMapper( + self.dbase.nid_trans, + self.dbase.find_next_note_gramps_id, + self.dbase.get_number_of_notes()) - self.gid2id = {} - self.oid2id = {} - self.sid2id = {} - self.lid2id = {} - self.fid2id = {} - self.rid2id = {} + self.gid2id = {} + self.oid2id = {} + self.sid2id = {} + self.lid2id = {} + self.fid2id = {} + self.rid2id = {} # # Parse table for INDI tag # - self.indi_parse_tbl = { - # +1 RESN {0:1} - TOKEN_RESN : self.func_person_resn, - # +1 <> {0:M} - TOKEN_NAME : self.func_person_name, - # +1 SEX {0:1} - TOKEN_SEX : self.func_person_sex, - # +1 <> {0:M} - TOKEN_EVEN : self.func_person_even, - TOKEN_GEVENT: self.func_person_std_event, - TOKEN_BIRT : self.func_person_birt, - TOKEN_RELI : self.func_person_reli, - TOKEN_ADOP : self.func_person_adop, - TOKEN_DEAT : self.func_person_deat, - TOKEN_RESI : self.func_person_resi, - # +1 <> {0:M} - # +1 AFN {0:1} - TOKEN_ATTR : self.func_person_std_attr, - #+1 <> {0:M} - TOKEN_BAPL : self.func_person_bapl, - TOKEN_CONL : self.func_person_conl, - TOKEN_ENDL : self.func_person_endl, - TOKEN_SLGC : self.func_person_slgc, - #+1 <> {0:M} - TOKEN_FAMC : self.func_person_famc, - # +1 <> {0:M} - TOKEN_FAMS : self.func_person_fams, - # +1 SUBM @@ {0:M} - TOKEN_SUBM : self.skip_record, - # +1 <> {0:M} - TOKEN_ASSO : self.func_person_asso, - # +1 ALIA @@ {0:M} - TOKEN_ALIA : self.func_person_alt_name, - # +1 ANCI @@ {0:M} - TOKEN_ANCI : self.skip_record, - # +1 DESI @@ {0:M} - TOKEN_DESI : self.skip_record, - # +1 <> {0:M} - TOKEN_SOUR : self.func_person_sour, - # +1 <> {0:M} - TOKEN_OBJE : self.func_person_object, - # +1 <> {0:M} - TOKEN_NOTE : self.func_person_note, - TOKEN_RNOTE : self.func_person_note, - TOKEN__COMM : self.func_person_note, - # +1 RFN {0:1} - TOKEN_RFN : self.func_person_attr, - # +1 REFN {0:M} - # +2 TYPE {0:1} - TOKEN_REFN : self.func_person_refn, - # +1 RIN {0:1} - TOKEN_RIN : self.skip_record, - # +1 <> {0:1} - TOKEN_CHAN : self.func_person_chan, + self.indi_parse_tbl = { + # +1 RESN {0:1} + TOKEN_RESN : self.__person_resn, + # +1 <> {0:M} + TOKEN_NAME : self.__person_name, + # +1 SEX {0:1} + TOKEN_SEX : self.__person_sex, + # +1 <> {0:M} + TOKEN_EVEN : self.__person_even, + TOKEN_GEVENT: self.__person_std_event, + TOKEN_BIRT : self.__person_birt, + TOKEN_RELI : self.__person_reli, + TOKEN_ADOP : self.__person_adop, + TOKEN_DEAT : self.__person_deat, + TOKEN_RESI : self.__person_resi, + # +1 <> {0:M} + # +1 AFN {0:1} + TOKEN_ATTR : self.__person_std_attr, + #+1 <> {0:M} + TOKEN_BAPL : self.__person_bapl, + TOKEN_CONL : self.__person_conl, + TOKEN_ENDL : self.__person_endl, + TOKEN_SLGC : self.__person_slgc, + #+1 <> {0:M} + TOKEN_FAMC : self.__person_famc, + # +1 <> {0:M} + TOKEN_FAMS : self.__person_fams, + # +1 SUBM @@ {0:M} + TOKEN_SUBM : self.__skip_record, + # +1 <> {0:M} + TOKEN_ASSO : self.__person_asso, + # +1 ALIA @@ {0:M} + TOKEN_ALIA : self.__person_alt_name, + # +1 ANCI @@ {0:M} + TOKEN_ANCI : self.__skip_record, + # +1 DESI @@ {0:M} + TOKEN_DESI : self.__skip_record, + # +1 <> {0:M} + TOKEN_SOUR : self.__person_sour, + # +1 <> {0:M} + TOKEN_OBJE : self.__person_object, + # +1 <> {0:M} + TOKEN_NOTE : self.__person_note, + TOKEN_RNOTE : self.__person_note, + TOKEN__COMM : self.__person_note, + # +1 RFN {0:1} + TOKEN_RFN : self.__person_attr, + # +1 REFN {0:M} + # +2 TYPE {0:1} + TOKEN_REFN : self.__person_refn, + # +1 RIN {0:1} + TOKEN_RIN : self.__skip_record, + # +1 <> {0:1} + TOKEN_CHAN : self.__person_chan, - TOKEN_ADDR : self.func_person_addr, - TOKEN_PHON : self.func_person_phon, - TOKEN__TODO : self.skip_record, - TOKEN_TITL : self.func_person_titl, - } + TOKEN_ADDR : self.__person_addr, + TOKEN_PHON : self.__person_phon, + TOKEN__TODO : self.__skip_record, + TOKEN_TITL : self.__person_titl, + } # # Parse table for INDI.NAME # - self.name_parse_tbl = { - # +1 NPFX {0:1} - TOKEN_NPFX : self.func_name_npfx, - # +1 GIVN {0:1} - TOKEN_GIVN : self.func_name_givn, - # NICK {0:1} - TOKEN_NICK : self.func_name_nick, - # +1 SPFX {0:1} - TOKEN_SURN : self.func_name_surn, - # +1 NSFX {0:1} - TOKEN_NSFX : self.func_name_nsfx, - # +1 <> {0:M} - TOKEN_SOUR : self.func_name_sour, - # +1 <> {0:M} - TOKEN_NOTE : self.func_name_note, - TOKEN_RNOTE : self.func_name_note, - # Extensions - TOKEN_ALIA : self.func_name_alia, - TOKEN__MARNM : self.func_name_marnm, - TOKEN__AKA : self.func_name_aka, - TOKEN_TYPE : self.func_name_type, - TOKEN_BIRT : self.func_ignore, - } + self.name_parse_tbl = { + # +1 NPFX {0:1} + TOKEN_NPFX : self.__name_npfx, + # +1 GIVN {0:1} + TOKEN_GIVN : self.__name_givn, + # NICK {0:1} + TOKEN_NICK : self.__name_nick, + # +1 SPFX {0:1} + TOKEN_SURN : self.__name_surn, + # +1 NSFX {0:1} + TOKEN_NSFX : self.__name_nsfx, + # +1 <> {0:M} + TOKEN_SOUR : self.__name_sour, + # +1 <> {0:M} + TOKEN_NOTE : self.__name_note, + TOKEN_RNOTE : self.__name_note, + # Extensions + TOKEN_ALIA : self.__name_alia, + TOKEN__MARNM : self.__name_marnm, + TOKEN__AKA : self.__name_aka, + TOKEN_TYPE : self.__name_type, + TOKEN_BIRT : self.__ignore, + } - self.repo_parse_tbl = { - TOKEN_NAME : self.func_repo_name, - TOKEN_ADDR : self.func_repo_addr, - TOKEN_RIN : self.func_ignore, - } + self.repo_parse_tbl = { + TOKEN_NAME : self.__repo_name, + TOKEN_ADDR : self.__repo_addr, + TOKEN_RIN : self.__ignore, + } - self.event_parse_tbl = { - # n TYPE {0:1} - TOKEN_TYPE : self.func_event_type, - # n DATE {0:1} p.*/* - TOKEN_DATE : self.func_event_date, - # n <> {0:1} p.* - TOKEN_PLAC : self.func_event_place, - # n <> {0:1} p.* - TOKEN_ADDR : self.func_event_addr, - # n AGE {0:1} p.* - TOKEN_AGE : self.func_event_age, - # n AGNC {0:1} p.* - TOKEN_AGNC : self.func_event_agnc, - # n CAUS {0:1} p.* - TOKEN_CAUS : self.func_event_cause, - # n <> {0:M} p.* - TOKEN_SOUR : self.func_event_source, - # n <> {0:M} p.*,* - TOKEN_OBJE : self.func_event_object, - # n <> {0:M} p. - TOKEN_NOTE : self.func_event_note, - TOKEN_RNOTE : self.func_event_note, - # Other - TOKEN__PRIV : self.func_event_privacy, - TOKEN_OFFI : self.func_event_note, - TOKEN_PHON : self.func_ignore, - TOKEN__GODP : self.func_event_witness, - TOKEN__WITN : self.func_event_witness, - TOKEN__WTN : self.func_event_witness, - TOKEN_RELI : self.func_ignore, - TOKEN_TIME : self.func_ignore, - TOKEN_ASSO : self.func_ignore, - TOKEN_IGNORE : self.func_ignore, - TOKEN_STAT : self.func_ignore, - TOKEN_TEMP : self.func_ignore, - TOKEN_HUSB : self.func_event_husb, - TOKEN_WIFE : self.func_event_wife, - TOKEN_FAMC : self.func_person_birth_famc, - # Not legal, but inserted by Ultimate Family Tree - TOKEN_CHAN : self.func_ignore, - TOKEN_QUAY : self.func_ignore, - } + self.event_parse_tbl = { + # n TYPE {0:1} + TOKEN_TYPE : self.__event_type, + # n DATE {0:1} p.*/* + TOKEN_DATE : self.__event_date, + # n <> {0:1} p.* + TOKEN_PLAC : self.__event_place, + # n <> {0:1} p.* + TOKEN_ADDR : self.__event_addr, + # n AGE {0:1} p.* + TOKEN_AGE : self.__event_age, + # n AGNC {0:1} p.* + TOKEN_AGNC : self.__event_agnc, + # n CAUS {0:1} p.* + TOKEN_CAUS : self.__event_cause, + # n <> {0:M} p.* + TOKEN_SOUR : self.__event_source, + # n <> {0:M} p.*,* + TOKEN_OBJE : self.__event_object, + # n <> {0:M} p. + TOKEN_NOTE : self.__event_note, + TOKEN_RNOTE : self.__event_note, + # Other + TOKEN__PRIV : self.__event_privacy, + TOKEN_OFFI : self.__event_note, + TOKEN_PHON : self.__ignore, + TOKEN__GODP : self.__event_witness, + TOKEN__WITN : self.__event_witness, + TOKEN__WTN : self.__event_witness, + TOKEN_RELI : self.__ignore, + TOKEN_TIME : self.__ignore, + TOKEN_ASSO : self.__ignore, + TOKEN_IGNORE : self.__ignore, + TOKEN_STAT : self.__ignore, + TOKEN_TEMP : self.__ignore, + TOKEN_HUSB : self.__event_husb, + TOKEN_WIFE : self.__event_wife, + TOKEN_FAMC : self.__person_birth_famc, + # Not legal, but inserted by Ultimate Family Tree + TOKEN_CHAN : self.__ignore, + TOKEN_QUAY : self.__ignore, + } - self.adopt_parse_tbl = { - TOKEN_TYPE : self.func_event_type, - TOKEN__PRIV : self.func_event_privacy, - TOKEN_DATE : self.func_event_date, - TOKEN_SOUR : self.func_event_source, - TOKEN_PLAC : self.func_event_place, - TOKEN_ADDR : self.func_event_addr, - TOKEN_CAUS : self.func_event_cause, - TOKEN_AGNC : self.func_event_agnc, - TOKEN_AGE : self.func_event_age, - TOKEN_NOTE : self.func_event_note, - TOKEN_RNOTE : self.func_event_note, - TOKEN_OFFI : self.func_event_note, - TOKEN__GODP : self.func_event_witness, - TOKEN__WITN : self.func_event_witness, - TOKEN__WTN : self.func_event_witness, - TOKEN_RELI : self.func_ignore, - TOKEN_TIME : self.func_ignore, - TOKEN_ASSO : self.func_ignore, - TOKEN_IGNORE : self.func_ignore, - TOKEN_STAT : self.func_ignore, - TOKEN_TEMP : self.func_ignore, - TOKEN_OBJE : self.func_event_object, - TOKEN_FAMC : self.func_person_adopt_famc, - # Not legal, but inserted by Ultimate Family Tree - TOKEN_CHAN : self.func_ignore, - TOKEN_QUAY : self.func_ignore, - } + self.adopt_parse_tbl = { + TOKEN_TYPE : self.__event_type, + TOKEN__PRIV : self.__event_privacy, + TOKEN_DATE : self.__event_date, + TOKEN_SOUR : self.__event_source, + TOKEN_PLAC : self.__event_place, + TOKEN_ADDR : self.__event_addr, + TOKEN_CAUS : self.__event_cause, + TOKEN_AGNC : self.__event_agnc, + TOKEN_AGE : self.__event_age, + TOKEN_NOTE : self.__event_note, + TOKEN_RNOTE : self.__event_note, + TOKEN_OFFI : self.__event_note, + TOKEN__GODP : self.__event_witness, + TOKEN__WITN : self.__event_witness, + TOKEN__WTN : self.__event_witness, + TOKEN_RELI : self.__ignore, + TOKEN_TIME : self.__ignore, + TOKEN_ASSO : self.__ignore, + TOKEN_IGNORE : self.__ignore, + TOKEN_STAT : self.__ignore, + TOKEN_TEMP : self.__ignore, + TOKEN_OBJE : self.__event_object, + TOKEN_FAMC : self.__person_adopt_famc, + # Not legal, but inserted by Ultimate Family Tree + TOKEN_CHAN : self.__ignore, + TOKEN_QUAY : self.__ignore, + } - self.famc_parse_tbl = { - # n FAMC @@ {1:1} - # +1 PEDI {0:M} p.* - TOKEN_PEDI : self.func_person_famc_pedi, - # +1 <> {0:M} p.* - TOKEN_NOTE : self.func_person_famc_note, - TOKEN_RNOTE : self.func_person_famc_note, - # Extras - TOKEN__PRIMARY: self.func_person_famc_primary, - TOKEN_SOUR : self.func_person_famc_sour, - # GEDit - TOKEN_STAT : self.func_ignore, - } + self.famc_parse_tbl = { + # n FAMC @@ {1:1} + # +1 PEDI {0:M} p.* + TOKEN_PEDI : self.__person_famc_pedi, + # +1 <> {0:M} p.* + TOKEN_NOTE : self.__person_famc_note, + TOKEN_RNOTE : self.__person_famc_note, + # Extras + TOKEN__PRIMARY: self.__person_famc_primary, + TOKEN_SOUR : self.__person_famc_sour, + # GEDit + TOKEN_STAT : self.__ignore, + } - self.resi_parse_tbl = { - TOKEN_DATE : self.func_person_resi_date, - TOKEN_ADDR : self.func_person_resi_addr, - TOKEN_SOUR : self.func_person_resi_sour, - TOKEN_PLAC : self.func_person_resi_plac, - TOKEN_PHON : self.func_person_resi_phon, - TOKEN_NOTE : self.func_person_resi_note, - TOKEN_RNOTE : self.func_person_resi_note, - TOKEN_IGNORE : self.func_ignore, - TOKEN_CAUS : self.func_ignore, - TOKEN_STAT : self.func_ignore, - TOKEN_TEMP : self.func_ignore, - TOKEN_OBJE : self.func_ignore, - TOKEN_TYPE : self.func_ignore, - } + self.resi_parse_tbl = { + TOKEN_DATE : self.__person_resi_date, + TOKEN_ADDR : self.__person_resi_addr, + TOKEN_SOUR : self.__person_resi_sour, + TOKEN_PLAC : self.__person_resi_plac, + TOKEN_PHON : self.__person_resi_phon, + TOKEN_NOTE : self.__person_resi_note, + TOKEN_RNOTE : self.__person_resi_note, + TOKEN_IGNORE : self.__ignore, + TOKEN_CAUS : self.__ignore, + TOKEN_STAT : self.__ignore, + TOKEN_TEMP : self.__ignore, + TOKEN_OBJE : self.__ignore, + TOKEN_TYPE : self.__ignore, + } - self.person_attr_parse_tbl = { - TOKEN_TYPE : self.func_person_attr_type, - TOKEN_CAUS : self.func_ignore, - TOKEN_DATE : self.func_ignore, - TOKEN_TIME : self.func_ignore, - TOKEN_ADDR : self.func_ignore, - TOKEN_IGNORE: self.func_ignore, - TOKEN_STAT : self.func_ignore, - TOKEN_TEMP : self.func_ignore, - TOKEN_OBJE : self.func_ignore, - TOKEN_SOUR : self.func_person_attr_source, - TOKEN_PLAC : self.func_person_attr_place, - TOKEN_NOTE : self.func_person_attr_note, - TOKEN_RNOTE : self.func_person_attr_note, - } + self.person_attr_parse_tbl = { + TOKEN_TYPE : self.__person_attr_type, + TOKEN_CAUS : self.__ignore, + TOKEN_DATE : self.__ignore, + TOKEN_TIME : self.__ignore, + TOKEN_ADDR : self.__ignore, + TOKEN_IGNORE : self.__ignore, + TOKEN_STAT : self.__ignore, + TOKEN_TEMP : self.__ignore, + TOKEN_OBJE : self.__ignore, + TOKEN_SOUR : self.__person_attr_source, + TOKEN_PLAC : self.__person_attr_place, + TOKEN_NOTE : self.__person_attr_note, + TOKEN_RNOTE : self.__person_attr_note, + } - self.lds_parse_tbl = { - TOKEN_TEMP : self.func_lds_temple, - TOKEN_DATE : self.func_lds_date, - TOKEN_FAMC : self.func_lds_famc, - TOKEN_FORM : self.func_lds_form, - TOKEN_PLAC : self.func_lds_plac, - TOKEN_SOUR : self.func_lds_sour, - TOKEN_NOTE : self.func_lds_note, - TOKEN_RNOTE : self.func_lds_note, - TOKEN_STAT : self.func_lds_stat, - } + self.lds_parse_tbl = { + TOKEN_TEMP : self.__lds_temple, + TOKEN_DATE : self.__lds_date, + TOKEN_FAMC : self.__lds_famc, + TOKEN_FORM : self.__lds_form, + TOKEN_PLAC : self.__lds_plac, + TOKEN_SOUR : self.__lds_sour, + TOKEN_NOTE : self.__lds_note, + TOKEN_RNOTE : self.__lds_note, + TOKEN_STAT : self.__lds_stat, + } - self.asso_parse_tbl = { - TOKEN_TYPE : self.func_person_asso_type, - TOKEN_RELA : self.func_person_asso_rela, - TOKEN_SOUR : self.func_person_asso_sour, - TOKEN_NOTE : self.func_person_asso_note, - TOKEN_RNOTE : self.func_person_asso_note, - } + self.asso_parse_tbl = { + TOKEN_TYPE : self.__person_asso_type, + TOKEN_RELA : self.__person_asso_rela, + TOKEN_SOUR : self.__person_asso_sour, + TOKEN_NOTE : self.__person_asso_note, + TOKEN_RNOTE : self.__person_asso_note, + } - self.srcref_parse_tbl = { - TOKEN_PAGE : self.func_srcref_page, - TOKEN_DATE : self.func_srcref_date, - TOKEN_DATA : self.func_srcref_data, - TOKEN_OBJE : self.func_srcref_obje, - TOKEN_REFN : self.func_srcref_refn, - TOKEN_EVEN : self.func_ignore, - TOKEN_IGNORE : self.func_ignore, - TOKEN__LKD : self.func_ignore, - TOKEN_QUAY : self.func_srcref_quay, - TOKEN_NOTE : self.func_srcref_note, - TOKEN_RNOTE : self.func_srcref_note, - TOKEN_TEXT : self.func_srcref_text, - } + self.srcref_parse_tbl = { + TOKEN_PAGE : self.__srcref_page, + TOKEN_DATE : self.__srcref_date, + TOKEN_DATA : self.__srcref_data, + TOKEN_OBJE : self.__srcref_obje, + TOKEN_REFN : self.__srcref_refn, + TOKEN_EVEN : self.__ignore, + TOKEN_IGNORE : self.__ignore, + TOKEN__LKD : self.__ignore, + TOKEN_QUAY : self.__srcref_quay, + TOKEN_NOTE : self.__srcref_note, + TOKEN_RNOTE : self.__srcref_note, + TOKEN_TEXT : self.__srcref_text, + } - self.object_parse_tbl = { - TOKEN_FORM : self.func_object_ref_form, - TOKEN_TITL : self.func_object_ref_titl, - TOKEN_FILE : self.func_object_ref_file, - TOKEN_NOTE : self.func_object_ref_note, - TOKEN_RNOTE : self.func_object_ref_note, - TOKEN_IGNORE : self.func_ignore, - } + self.object_parse_tbl = { + TOKEN_FORM : self.__object_ref_form, + TOKEN_TITL : self.__object_ref_titl, + TOKEN_FILE : self.__object_ref_file, + TOKEN_NOTE : self.__object_ref_note, + TOKEN_RNOTE : self.__object_ref_note, + TOKEN_IGNORE : self.__ignore, + } - self.parse_loc_tbl = { - TOKEN_ADDR : self.func_location_addr, - TOKEN_ADR1 : self.func_location_addr, - TOKEN_ADR2 : self.func_location_addr, - TOKEN_DATE : self.func_location_date, - TOKEN_CITY : self.func_location_city, - TOKEN_STAE : self.func_location_stae, - TOKEN_POST : self.func_location_post, - TOKEN_CTRY : self.func_location_ctry, - TOKEN_NOTE : self.func_location_note, - TOKEN_RNOTE : self.func_location_note, - TOKEN__LOC : self.func_ignore, - TOKEN__NAME : self.func_ignore, - TOKEN_PHON : self.func_ignore, - TOKEN_IGNORE : self.func_ignore, - } - + self.parse_loc_tbl = { + TOKEN_ADDR : self.__location_addr, + TOKEN_ADR1 : self.__location_addr, + TOKEN_ADR2 : self.__location_addr, + TOKEN_DATE : self.__location_date, + TOKEN_CITY : self.__location_city, + TOKEN_STAE : self.__location_stae, + TOKEN_POST : self.__location_post, + TOKEN_CTRY : self.__location_ctry, + TOKEN_NOTE : self.__location_note, + TOKEN_RNOTE : self.__location_note, + TOKEN__LOC : self.__ignore, + TOKEN__NAME : self.__ignore, + TOKEN_PHON : self.__ignore, + TOKEN_IGNORE : self.__ignore, + } + # # FAM # - self.family_func = { + self.family_func = { # +1 <> {0:M} - TOKEN_GEVENT: self.func_family_std_event, - TOKEN_EVEN : self.func_family_even, + TOKEN_GEVENT : self.__family_std_event, + TOKEN_EVEN : self.__family_even, # +1 HUSB @@ {0:1} - TOKEN_HUSB : self.func_family_husb, + TOKEN_HUSB : self.__family_husb, # +1 WIFE @@ {0:1} - TOKEN_WIFE : self.func_family_wife, + TOKEN_WIFE : self.__family_wife, # +1 CHIL @@ {0:M} - TOKEN_CHIL : self.func_family_chil, + TOKEN_CHIL : self.__family_chil, # +1 NCHI {0:1} # +1 SUBM @@ {0:M} - # +1 <> {0:M} - TOKEN_SLGS : self.func_family_slgs, + # +1 <> {0:M} + TOKEN_SLGS : self.__family_slgs, # +1 <> {0:M} - TOKEN_SOUR : self.func_family_source, + TOKEN_SOUR : self.__family_source, # +1 <> {0:M} - TOKEN_OBJE : self.func_family_object, + TOKEN_OBJE : self.__family_object, # +1 <> {0:M} - TOKEN__COMM : self.func_family_comm, - TOKEN_NOTE : self.func_family_note, - TOKEN_RNOTE : self.func_family_note, + TOKEN__COMM : self.__family_comm, + TOKEN_NOTE : self.__family_note, + TOKEN_RNOTE : self.__family_note, # +1 REFN {0:M} - TOKEN_REFN : self.func_ignore, + TOKEN_REFN : self.__ignore, # +1 RIN {0:1} # +1 <> {0:1} - TOKEN_CHAN : self.func_family_chan, - TOKEN_ENDL : self.func_ignore, + TOKEN_CHAN : self.__family_chan, + TOKEN_ENDL : self.__ignore, - TOKEN_ADDR : self.func_family_addr, - TOKEN_RIN : self.func_family_cust_attr, - TOKEN_SUBM : self.func_ignore, - TOKEN_ATTR : self.func_family_attr, - } + TOKEN_ADDR : self.__family_addr, + TOKEN_RIN : self.__family_cust_attr, + TOKEN_SUBM : self.__ignore, + TOKEN_ATTR : self.__family_attr, + } - self.family_rel_tbl = { - TOKEN__FREL : self.func_family_frel, - TOKEN__MREL : self.func_family_mrel, - TOKEN_ADOP : self.func_family_adopt, - TOKEN__STAT : self.func_family_stat, - } + self.family_rel_tbl = { + TOKEN__FREL : self.__family_frel, + TOKEN__MREL : self.__family_mrel, + TOKEN_ADOP : self.__family_adopt, + TOKEN__STAT : self.__family_stat, + } - self.source_func = { - TOKEN_TITL : self.func_source_title, - TOKEN_TAXT : self.func_source_taxt_peri, - TOKEN_PERI : self.func_source_taxt_peri, - TOKEN_AUTH : self.func_source_auth, - TOKEN_PUBL : self.func_source_publ, - TOKEN_NOTE : self.func_source_note, - TOKEN_RNOTE : self.func_source_note, - TOKEN_TEXT : self.func_source_text, - TOKEN_ABBR : self.func_source_abbr, - TOKEN_REFN : self.func_ignore, - TOKEN_RIN : self.func_ignore, - TOKEN_REPO : self.func_source_repo, - TOKEN_OBJE : self.func_source_object, - TOKEN_CHAN : self.func_source_chan, - TOKEN_MEDI : self.func_source_attr, - TOKEN__NAME : self.func_source_attr, - TOKEN_DATA : self.func_ignore, - TOKEN_TYPE : self.func_source_attr, - TOKEN_CALN : self.func_ignore, - # not legal, but Ultimate Family Tree does this - TOKEN_DATE : self.func_ignore, - TOKEN_IGNORE: self.func_ignore, - } + self.source_func = { + TOKEN_TITL : self.__source_title, + TOKEN_TAXT : self.__source_taxt_peri, + TOKEN_PERI : self.__source_taxt_peri, + TOKEN_AUTH : self.__source_auth, + TOKEN_PUBL : self.__source_publ, + TOKEN_NOTE : self.__source_note, + TOKEN_RNOTE : self.__source_note, + TOKEN_TEXT : self.__source_text, + TOKEN_ABBR : self.__source_abbr, + TOKEN_REFN : self.__ignore, + TOKEN_RIN : self.__ignore, + TOKEN_REPO : self.__source_repo, + TOKEN_OBJE : self.__source_object, + TOKEN_CHAN : self.__source_chan, + TOKEN_MEDI : self.__source_attr, + TOKEN__NAME : self.__source_attr, + TOKEN_DATA : self.__ignore, + TOKEN_TYPE : self.__source_attr, + TOKEN_CALN : self.__ignore, + # not legal, but Ultimate Family Tree does this + TOKEN_DATE : self.__ignore, + TOKEN_IGNORE : self.__ignore, + } - self.obje_func = { - TOKEN_FORM : self.func_obje_form, - TOKEN_TITL : self.func_obje_title, - TOKEN_FILE : self.func_obje_file, - TOKEN_NOTE : self.func_obje_note, - TOKEN_RNOTE : self.func_obje_note, - TOKEN_BLOB : self.func_obje_blob, - TOKEN_REFN : self.func_obje_refn, - TOKEN_TYPE : self.func_obje_type, - TOKEN_RIN : self.func_obje_rin, - TOKEN_CHAN : self.func_obje_chan, - } + self.obje_func = { + TOKEN_FORM : self.__obje_form, + TOKEN_TITL : self.__obje_title, + TOKEN_FILE : self.__obje_file, + TOKEN_NOTE : self.__obje_note, + TOKEN_RNOTE : self.__obje_note, + TOKEN_BLOB : self.__obje_blob, + TOKEN_REFN : self.__obje_refn, + TOKEN_TYPE : self.__obje_type, + TOKEN_RIN : self.__obje_rin, + TOKEN_CHAN : self.__obje_chan, + } - self.parse_addr_tbl = { - TOKEN_DATE : self.func_address_date, - TOKEN_CITY : self.func_address_city, - TOKEN_STAE : self.func_address_state, - TOKEN_POST : self.func_address_post, - TOKEN_CTRY : self.func_address_country, - TOKEN_PHON : self.func_address_phone, - TOKEN_SOUR : self.func_address_sour, - TOKEN_NOTE : self.func_address_note, - TOKEN_RNOTE : self.func_address_note, - TOKEN__LOC : self.func_ignore, - TOKEN__NAME : self.func_ignore, - TOKEN_IGNORE: self.func_ignore, - TOKEN_TYPE : self.func_ignore, - TOKEN_CAUS : self.func_ignore, - } + self.parse_addr_tbl = { + TOKEN_DATE : self.__address_date, + TOKEN_CITY : self.__address_city, + TOKEN_STAE : self.__address_state, + TOKEN_POST : self.__address_post, + TOKEN_CTRY : self.__address_country, + TOKEN_PHON : self.__address_phone, + TOKEN_SOUR : self.__address_sour, + TOKEN_NOTE : self.__address_note, + TOKEN_RNOTE : self.__address_note, + TOKEN__LOC : self.__ignore, + TOKEN__NAME : self.__ignore, + TOKEN_IGNORE : self.__ignore, + TOKEN_TYPE : self.__ignore, + TOKEN_CAUS : self.__ignore, + } - self.event_cause_tbl = { - TOKEN_SOUR : self.func_event_cause_source, - } + self.event_cause_tbl = { + TOKEN_SOUR : self.__event_cause_source, + } - self.event_place_map = { - TOKEN_NOTE : self.func_event_place_note, - TOKEN_RNOTE : self.func_event_place_note, - TOKEN_FORM : self.func_event_place_form, - TOKEN_OBJE : self.func_event_place_object, - TOKEN_SOUR : self.func_event_place_sour, - TOKEN__LOC : self.func_ignore, - TOKEN_MAP : self.func_place_map, - # Not legal, but generated by Ultimate Family Tree - TOKEN_QUAY : self.func_ignore, - } + self.event_place_map = { + TOKEN_NOTE : self.__event_place_note, + TOKEN_RNOTE : self.__event_place_note, + TOKEN_FORM : self.__event_place_form, + TOKEN_OBJE : self.__event_place_object, + TOKEN_SOUR : self.__event_place_sour, + TOKEN__LOC : self.__ignore, + TOKEN_MAP : self.__place_map, + # Not legal, but generated by Ultimate Family Tree + TOKEN_QUAY : self.__ignore, + } - self.place_map_tbl = { - TOKEN_LATI : self.func_place_lati, - TOKEN_LONG : self.func_place_long, - } + self.place_map_tbl = { + TOKEN_LATI : self.__place_lati, + TOKEN_LONG : self.__place_long, + } - self.repo_ref_tbl = { - TOKEN_CALN : self.func_repo_ref_call, - TOKEN_NOTE : self.func_repo_ref_note, - TOKEN_RNOTE : self.func_repo_ref_note, - TOKEN_MEDI : self.func_repo_ref_medi, - TOKEN_IGNORE : self.func_ignore, - } + self.repo_ref_tbl = { + TOKEN_CALN : self.__repo_ref_call, + TOKEN_NOTE : self.__repo_ref_note, + TOKEN_RNOTE : self.__repo_ref_note, + TOKEN_MEDI : self.__repo_ref_medi, + TOKEN_IGNORE : self.__ignore, + } - self.parse_person_adopt = { - TOKEN_ADOP : self.func_person_adopt_famc_adopt, - } + self.parse_person_adopt = { + TOKEN_ADOP : self.__person_adopt_famc_adopt, + } - self.opt_note_tbl = { - TOKEN_RNOTE: self.func_optional_note, - TOKEN_NOTE: self.func_optional_note, - } + self.opt_note_tbl = { + TOKEN_RNOTE : self.__optional_note, + TOKEN_NOTE : self.__optional_note, + } - self.srcref_data_tbl = { - TOKEN_DATE : self.func_source_data_date, - TOKEN_TEXT : self.func_source_data_text, - TOKEN_RNOTE: self.func_source_data_note, - TOKEN_NOTE : self.func_source_data_note, - } + self.srcref_data_tbl = { + TOKEN_DATE : self.__source_data_date, + TOKEN_TEXT : self.__source_data_text, + TOKEN_RNOTE : self.__source_data_note, + TOKEN_NOTE : self.__source_data_note, + } - self.header_sour = { - TOKEN_SOUR : self.func_header_sour, - TOKEN_NAME : self.func_ignore, - TOKEN_VERS : self.func_header_vers, - TOKEN_FILE : self.func_header_file, - TOKEN_COPR : self.func_header_copr, - TOKEN_SUBM : self.func_header_subm, - TOKEN_CORP : self.func_ignore, - TOKEN_DATA : self.func_ignore, - TOKEN_SUBN : self.func_ignore, - TOKEN_LANG : self.func_ignore, - TOKEN_TIME : self.func_ignore, - TOKEN_DEST : self.func_header_dest, - TOKEN_CHAR : self.func_ignore, - TOKEN_GEDC : self.func_ignore, - TOKEN__SCHEMA: self.func_ignore, - TOKEN_PLAC : self.func_header_plac, - TOKEN_DATE : self.func_header_date, - TOKEN_NOTE : self.func_header_note, - } + self.header_sour = { + TOKEN_SOUR : self.__header_sour, + TOKEN_NAME : self.__ignore, + TOKEN_VERS : self.__header_vers, + TOKEN_FILE : self.__header_file, + TOKEN_COPR : self.__header_copr, + TOKEN_SUBM : self.__header_subm, + TOKEN_CORP : self.__ignore, + TOKEN_DATA : self.__ignore, + TOKEN_SUBN : self.__ignore, + TOKEN_LANG : self.__ignore, + TOKEN_TIME : self.__ignore, + TOKEN_DEST : self.__header_dest, + TOKEN_CHAR : self.__ignore, + TOKEN_GEDC : self.__ignore, + TOKEN__SCHEMA: self.__ignore, + TOKEN_PLAC : self.__header_plac, + TOKEN_DATE : self.__header_date, + TOKEN_NOTE : self.__header_note, + } - self.header_subm = { - TOKEN_NAME : self.func_header_subm_name, - } + self.header_subm = { + TOKEN_NAME : self.__header_subm_name, + } - # look for existing place titles, build a map - self.place_names = {} - cursor = dbase.get_place_cursor() - data = cursor.next() - while data: - (handle, val) = data - self.place_names[val[2]] = handle - data = cursor.next() - cursor.close() + # look for existing place titles, build a map + self.place_names = {} + cursor = dbase.get_place_cursor() + data = cursor.next() + while data: + (handle, val) = data + self.place_names[val[2]] = handle + data = cursor.next() + cursor.close() - enc = stage_one.get_encoding() + enc = stage_one.get_encoding() - if enc == "ANSEL": - rdr = AnselReader(ifile) - elif enc in ("UTF-8", "UTF8"): - rdr = UTF8Reader(ifile) - elif enc in ("UTF-16", "UTF16", "UNICODE"): - rdr = UTF16Reader(ifile) - else: - rdr = AnsiReader(ifile) + if enc == "ANSEL": + rdr = AnselReader(ifile) + elif enc in ("UTF-8", "UTF8"): + rdr = UTF8Reader(ifile) + elif enc in ("UTF-16", "UTF16", "UNICODE"): + rdr = UTF16Reader(ifile) + else: + rdr = AnsiReader(ifile) - self.lexer = Reader(rdr) - self.filename = filename - self.backoff = False + self.lexer = Reader(rdr) + self.filename = filename + self.backoff = False - fullpath = os.path.normpath(os.path.abspath(filename)) - self.geddir = os.path.dirname(fullpath) + fullpath = os.path.normpath(os.path.abspath(filename)) + self.geddir = os.path.dirname(fullpath) - self.error_count = 0 - amap = personalConstantAttributes - - self.attrs = amap.values() - self.gedattr = {} - for val in amap.keys(): - self.gedattr[amap[val]] = val - self.search_paths = [] + self.error_count = 0 + amap = personalConstantAttributes + + self.attrs = amap.values() + self.gedattr = {} + for val in amap.keys(): + self.gedattr[amap[val]] = val + self.search_paths = [] #------------------------------------------------------------------------- # # Create new objects # #------------------------------------------------------------------------- - def _find_from_handle(self, gramps_id, table): - """ - Finds a handle corresponding the the specified GRAMPS ID. The passed - table contains the mapping. If the value is found, we return it, otherwise - we create a new handle, store it, and return it. - """ - intid = table.get(gramps_id) - if not intid: - intid = Utils.create_id() - table[gramps_id] = intid - return intid + def __find_from_handle(self, gramps_id, table): + """ + Finds a handle corresponding the the specified GRAMPS ID. The passed + table contains the mapping. If the value is found, we return it, otherwise + we create a new handle, store it, and return it. + """ + intid = table.get(gramps_id) + if not intid: + intid = Utils.create_id() + table[gramps_id] = intid + return intid - def find_person_handle(self, gramps_id): - """ - Returns the database handle associated with the person's GRAMPS ID - """ - return self._find_from_handle(gramps_id, self.gid2id) + def __find_person_handle(self, gramps_id): + """ + Returns the database handle associated with the person's GRAMPS ID + """ + return self.__find_from_handle(gramps_id, self.gid2id) - def find_family_handle(self, gramps_id): - """ - Returns the database handle associated with the family's GRAMPS ID - """ - return self._find_from_handle(gramps_id, self.fid2id) - - def find_object_handle(self, gramps_id): - """ - Returns the database handle associated with the media object's GRAMPS ID - """ - return self._find_from_handle(gramps_id, self.oid2id) + def __find_family_handle(self, gramps_id): + """ + Returns the database handle associated with the family's GRAMPS ID + """ + return self.__find_from_handle(gramps_id, self.fid2id) + + def __find_object_handle(self, gramps_id): + """ + Returns the database handle associated with the media object's GRAMPS ID + """ + return self.__find_from_handle(gramps_id, self.oid2id) - def find_or_create_person(self, gramps_id): - """ - Finds or creates a person based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new person, assign the handle and GRAMPS ID. - """ - person = RelLib.Person() - intid = self.gid2id.get(gramps_id) - if self.dbase.has_person_handle(intid): - person.unserialize(self.dbase.get_raw_person_data(intid)) - else: - intid = self._find_from_handle(gramps_id, self.gid2id) - person.set_handle(intid) - person.set_gramps_id(gramps_id) - return person + def __find_or_create_person(self, gramps_id): + """ + Finds or creates a person based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new person, assign the handle and GRAMPS ID. + """ + person = RelLib.Person() + intid = self.gid2id.get(gramps_id) + if self.dbase.has_person_handle(intid): + person.unserialize(self.dbase.get_raw_person_data(intid)) + else: + intid = self.__find_from_handle(gramps_id, self.gid2id) + person.set_handle(intid) + person.set_gramps_id(gramps_id) + return person - def find_or_create_family(self, gramps_id): - """ - Finds or creates a family based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new family, assign the handle and GRAMPS ID. - """ - family = RelLib.Family() - intid = self.fid2id.get(gramps_id) - if self.dbase.has_family_handle(intid): - family.unserialize(self.dbase.get_raw_family_data(intid)) - else: - intid = self._find_from_handle(gramps_id, self.fid2id) - family.set_handle(intid) - family.set_gramps_id(gramps_id) - return family + def __find_or_create_family(self, gramps_id): + """ + Finds or creates a family based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new family, assign the handle and GRAMPS ID. + """ + family = RelLib.Family() + intid = self.fid2id.get(gramps_id) + if self.dbase.has_family_handle(intid): + family.unserialize(self.dbase.get_raw_family_data(intid)) + else: + intid = self.__find_from_handle(gramps_id, self.fid2id) + family.set_handle(intid) + family.set_gramps_id(gramps_id) + return family - def find_or_create_object(self, gramps_id): - """ - Finds or creates a media object based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new media object, assign the handle and GRAMPS ID. - """ - obj = RelLib.MediaObject() - intid = self.oid2id.get(gramps_id) - if self.dbase.has_object_handle(intid): - obj.unserialize(self.dbase.get_raw_object_data(intid)) - else: - intid = self._find_from_handle(gramps_id, self.oid2id) - obj.set_handle(intid) - obj.set_gramps_id(gramps_id) - return obj + def __find_or_create_object(self, gramps_id): + """ + Finds or creates a media object based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new media object, assign the handle and GRAMPS ID. + """ + obj = RelLib.MediaObject() + intid = self.oid2id.get(gramps_id) + if self.dbase.has_object_handle(intid): + obj.unserialize(self.dbase.get_raw_object_data(intid)) + else: + intid = self.__find_from_handle(gramps_id, self.oid2id) + obj.set_handle(intid) + obj.set_gramps_id(gramps_id) + return obj - def find_or_create_source(self, gramps_id): - """ - Finds or creates a source based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new source, assign the handle and GRAMPS ID. - """ - obj = RelLib.Source() - intid = self.sid2id.get(gramps_id) - if self.dbase.has_source_handle(intid): - obj.unserialize(self.dbase.get_raw_source_data(intid)) - else: - intid = self._find_from_handle(gramps_id, self.sid2id) - obj.set_handle(intid) - obj.set_gramps_id(gramps_id) - return obj + def __find_or_create_source(self, gramps_id): + """ + Finds or creates a source based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new source, assign the handle and GRAMPS ID. + """ + obj = RelLib.Source() + intid = self.sid2id.get(gramps_id) + if self.dbase.has_source_handle(intid): + obj.unserialize(self.dbase.get_raw_source_data(intid)) + else: + intid = self.__find_from_handle(gramps_id, self.sid2id) + obj.set_handle(intid) + obj.set_gramps_id(gramps_id) + return obj - def find_or_create_repository(self, gramps_id): - """ - Finds or creates a repository based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new repository, assign the handle and GRAMPS ID. + def __find_or_create_repository(self, gramps_id): + """ + Finds or creates a repository based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new repository, assign the handle and GRAMPS ID. - Some GEDCOM "flavors" destroy the specification, and declare the repository - inline instead of in a object. - """ - repository = RelLib.Repository() - if not gramps_id: - need_commit = True - gramps_id = self.dbase.find_next_repository_gramps_id() - else: - need_commit = False + Some GEDCOM "flavors" destroy the specification, and declare the repository + inline instead of in a object. + """ + repository = RelLib.Repository() + if not gramps_id: + need_commit = True + gramps_id = self.dbase.find_next_repository_gramps_id() + else: + need_commit = False - intid = self.rid2id.get(gramps_id) - if self.dbase.has_repository_handle(intid): - repository.unserialize(self.dbase.get_raw_repository_data(intid)) - else: - intid = self._find_from_handle(gramps_id, self.rid2id) - repository.set_handle(intid) - repository.set_gramps_id(gramps_id) - if need_commit: - self.dbase.commit_repository(repository, self.trans) - return repository + intid = self.rid2id.get(gramps_id) + if self.dbase.has_repository_handle(intid): + repository.unserialize(self.dbase.get_raw_repository_data(intid)) + else: + intid = self.__find_from_handle(gramps_id, self.rid2id) + repository.set_handle(intid) + repository.set_gramps_id(gramps_id) + if need_commit: + self.dbase.commit_repository(repository, self.trans) + return repository - def find_or_create_place(self, title): - """ - Finds or creates a place based on the GRAMPS ID. If the ID is - already used (is in the db), we return the item in the db. Otherwise, - we create a new place, assign the handle and GRAMPS ID. - """ - place = RelLib.Place() + def __find_or_create_place(self, title): + """ + Finds or creates a place based on the GRAMPS ID. If the ID is + already used (is in the db), we return the item in the db. Otherwise, + we create a new place, assign the handle and GRAMPS ID. + """ + place = RelLib.Place() - # check to see if we've encountered this name before - # if we haven't we need to get a new GRAMPS ID - - intid = self.place_names.get(title) - if intid == None: - intid = self.lid2id.get(title) - if intid == None: - new_id = self.dbase.find_next_place_gramps_id() - else: - new_id = None - else: - new_id = None + # check to see if we've encountered this name before + # if we haven't we need to get a new GRAMPS ID + + intid = self.place_names.get(title) + if intid == None: + intid = self.lid2id.get(title) + if intid == None: + new_id = self.dbase.find_next_place_gramps_id() + else: + new_id = None + else: + new_id = None - # check to see if the name already existed in the database - # if it does, create a new name by appending the GRAMPS ID. - # generate a GRAMPS ID if needed - - if self.dbase.has_place_handle(intid): - place.unserialize(self.dbase.get_raw_place_data(intid)) - else: - intid = Utils.create_id() - place.set_handle(intid) - place.set_title(title) - place.set_gramps_id(new_id) - self.dbase.add_place(place, self.trans) - self.lid2id[title] = intid - return place + # check to see if the name already existed in the database + # if it does, create a new name by appending the GRAMPS ID. + # generate a GRAMPS ID if needed + + if self.dbase.has_place_handle(intid): + place.unserialize(self.dbase.get_raw_place_data(intid)) + else: + intid = Utils.create_id() + place.set_handle(intid) + place.set_title(title) + place.set_gramps_id(new_id) + self.dbase.add_place(place, self.trans) + self.lid2id[title] = intid + return place - def find_file(self, fullname, altpath): - tries = [] - fullname = fullname.replace('\\', os.path.sep) - tries.append(fullname) - - try: - if os.path.isfile(fullname): - return (1, fullname) - except UnicodeEncodeError: - # FIXME: problem possibly caused by umlaut/accented character - # in filename - return (0, tries) - other = os.path.join(altpath, fullname) - tries.append(other) - if os.path.isfile(other): - return (1, other) - other = os.path.join(altpath, os.path.basename(fullname)) - tries.append(other) - if os.path.isfile(other): - return (1, other) - if len(fullname) > 3: - if fullname[1] == ':': - fullname = fullname[2:] - for path in self.search_paths: - other = os.path.normpath("%s/%s" % (path, fullname)) - tries.append(other) - if os.path.isfile(other): - return (1, other) - return (0, tries) - else: - return (0, tries) + def __find_file(self, fullname, altpath): + tries = [] + fullname = fullname.replace('\\', os.path.sep) + tries.append(fullname) + + try: + if os.path.isfile(fullname): + return (1, fullname) + except UnicodeEncodeError: + # FIXME: problem possibly caused by umlaut/accented character + # in filename + return (0, tries) + other = os.path.join(altpath, fullname) + tries.append(other) + if os.path.isfile(other): + return (1, other) + other = os.path.join(altpath, os.path.basename(fullname)) + tries.append(other) + if os.path.isfile(other): + return (1, other) + if len(fullname) > 3: + if fullname[1] == ':': + fullname = fullname[2:] + for path in self.search_paths: + other = os.path.normpath("%s/%s" % (path, fullname)) + tries.append(other) + if os.path.isfile(other): + return (1, other) + return (0, tries) + else: + return (0, tries) - def level_is_finished(self, text, level): - """ - Check to see if the level has been completed, indicated by finding - a level indiciated by the passed level value. If the level is finished, - then make sure to call self.backup to reset the text pointer. - """ - done = text.level < level - if done: - self.backup() - return done + def __level_is_finished(self, text, level): + """ + Check to see if the level has been completed, indicated by finding + a level indiciated by the passed level value. If the level is finished, + then make sure to call self._backup to reset the text pointer. + """ + done = text.level < level + if done: + self._backup() + return done - def get_next(self): - """ - Gets the next line for analysis from the lexical analyzer. Return the - same value if the backup flag is set. - """ - if not self.backoff: - self.groups = self.lexer.readline() - self.update() - - # EOF ? - if not self.groups: - self.backoff = False - self.warn(TRUNC_MSG) - self.error_count += 1 - self.groups = None - raise Errors.GedcomError(TRUNC_MSG) + def __get_next_line(self): + """ + Gets the next line for analysis from the lexical analyzer. Return the + same value if the _backup flag is set. + """ + if not self.backoff: + self.groups = self.lexer.readline() + self.update() + + # EOF ? + if not self.groups: + self.backoff = False + self.warn(TRUNC_MSG) + self.error_count += 1 + self.groups = None + raise Errors.GedcomError(TRUNC_MSG) - self.backoff = False - return self.groups - - def not_recognized(self, level): - """ - Prints a message when an undefined token is found. All subordinate items - to the current item are ignored. + self.backoff = False + return self.groups + + def __not_recognized(self, level): + """ + Prints a message when an undefined token is found. All subordinate items + to the current item are ignored. - @param level: Current level in the file - @type level: int - """ - #import traceback - #traceback.print_stack() - text = self.groups.line - msg = _("Line %d was not understood, so it was ignored.") % text - self.warn(msg) - self.error_count += 1 - self.skip_subordinate_levels(level) + @param level: Current level in the file + @type level: int + """ + #import traceback + #traceback.print_stack() + text = self.groups.line + msg = _("Line %d was not understood, so it was ignored.") % text + self.warn(msg) + self.error_count += 1 + self.__skip_subordinate_levels(level) def warn(self, msg): - """ - Displays a msg using the logging facilities. - """ - LOG.warning(msg) - self.error_count += 1 + """ + Displays a msg using the logging facilities. + """ + LOG.warning(msg) + self.error_count += 1 - def backup(self): - """ - Sets the backup flag so that the current line can be accessed by the - next level up. - """ - self.backoff = True + def _backup(self): + """ + Sets the _backup flag so that the current line can be accessed by the + next level up. + """ + self.backoff = True def parse_gedcom_file(self, use_trans=False): - """ - Parses the opened GEDCOM file. - """ - no_magic = self.maxpeople < 1000 - self.trans = self.dbase.transaction_begin("", not use_trans, no_magic) + """ + Parses the opened GEDCOM file. + """ + no_magic = self.maxpeople < 1000 + self.trans = self.dbase.transaction_begin("", not use_trans, no_magic) - self.debug = False - self.dbase.disable_signals() - self.parse_header_head() - self.parse_header_source() - self.parse_submitter() - if self.use_def_src: - self.dbase.add_source(self.def_src, self.trans) - self.parse_record() - self.parse_trailer() - - for title in self.inline_srcs.keys(): - handle = self.inline_srcs[title] - src = RelLib.Source() - src.set_handle(handle) - src.set_title(title) - self.dbase.add_source(src, self.trans) - - self.dbase.transaction_commit(self.trans, _("GEDCOM import")) - self.dbase.enable_signals() - self.dbase.request_rebuild() - - def parse_trailer(self): - """ - Looks for the expected TRLR token - """ - try: - line = self.get_next() - if line and line.token != TOKEN_TRLR: - self.not_recognized(0) - except TypeError: - return - - def parse_submitter(self): - """ - Parses the submitter data - """ - line = self.get_next() - if line.data != "SUBM": - self.backup() - return - else: - while True: - line = self.get_next() - if self.level_is_finished(line, 1): - break - elif line.token == TOKEN_NAME: - if self.use_def_src: - self.def_src.set_author(line.data) - elif line.token == TOKEN_ADDR: - self.skip_subordinate_levels(2) + self.debug = False + self.dbase.disable_signals() + self.__parse_header_head() + self.__parse_header_source() + self.__parse_submitter() + if self.use_def_src: + self.dbase.add_source(self.def_src, self.trans) + self.__parse_record() + self.__parse_trailer() + + for title in self.inline_srcs.keys(): + handle = self.inline_srcs[title] + src = RelLib.Source() + src.set_handle(handle) + src.set_title(title) + self.dbase.add_source(src, self.trans) + + self.dbase.transaction_commit(self.trans, _("GEDCOM import")) + self.dbase.enable_signals() + self.dbase.request_rebuild() + + def __parse_trailer(self): + """ + Looks for the expected TRLR token + """ + try: + line = self.__get_next_line() + if line and line.token != TOKEN_TRLR: + self.__not_recognized(0) + except TypeError: + return + + def __parse_submitter(self): + """ + Parses the submitter data + """ + line = self.__get_next_line() + if line.data != "SUBM": + self._backup() + return + else: + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, 1): + break + elif line.token == TOKEN_NAME: + if self.use_def_src: + self.def_src.set_author(line.data) + elif line.token == TOKEN_ADDR: + self.__skip_subordinate_levels(2) - def parse_record(self): - """ - Parses the top level (0 level) instances. - """ - while True: - line = self.get_next() - key = line.data - if not line or line.token == TOKEN_TRLR: - self.backup() - break - if line.token == TOKEN_UNKNOWN: - self.skip_subordinate_levels(1) - elif key in ("FAM", "FAMILY"): - self.parse_fam(line) - elif key in ("INDI", "INDIVIDUAL"): - self.parse_indi(line) - elif key in ("OBJE", "OBJECT"): - self.parse_obje(line) - elif key in ("REPO", "REPOSITORY"): - self.parse_repo(line) - elif key in ("SUBM", "SUBN", "SUBMITTER"): - print line - self.skip_subordinate_levels(1) - elif line.token in (TOKEN_SUBM, TOKEN_SUBN, TOKEN_IGNORE): - self.skip_subordinate_levels(1) - elif key in ("SOUR","SOURCE"): - self.parse_source(line.token_text, 1) - elif line.data.startswith("SOUR ") or \ - line.data.startswith("SOURCE "): - print line - # A source formatted in a single line, for example: - # 0 @S62@ SOUR This is the title of the source - source = self.find_or_create_source(self.sid_map[line[3]]) - source.set_title(line.data[5:]) - self.dbase.commit_source(source, self.trans) - elif key[0:4] == "NOTE": - self.skip_subordinate_levels(1) - else: - self.not_recognized(1) + def __parse_record(self): + """ + Parses the top level (0 level) instances. + """ + while True: + line = self.__get_next_line() + key = line.data + if not line or line.token == TOKEN_TRLR: + self._backup() + break + if line.token == TOKEN_UNKNOWN: + self.__skip_subordinate_levels(1) + elif key in ("FAM", "FAMILY"): + self.__parse_fam(line) + elif key in ("INDI", "INDIVIDUAL"): + self.__parse_indi(line) + elif key in ("OBJE", "OBJECT"): + self.__parse_obje(line) + elif key in ("REPO", "REPOSITORY"): + self.__parse_repo(line) + elif key in ("SUBM", "SUBN", "SUBMITTER"): + print line + self.__skip_subordinate_levels(1) + elif line.token in (TOKEN_SUBM, TOKEN_SUBN, TOKEN_IGNORE): + self.__skip_subordinate_levels(1) + elif key in ("SOUR","SOURCE"): + self.__parse_source(line.token_text, 1) + elif line.data.startswith("SOUR ") or \ + line.data.startswith("SOURCE "): + print line + # A source formatted in a single line, for example: + # 0 @S62@ SOUR This is the title of the source + source = self.__find_or_create_source(self.sid_map[line[3]]) + source.set_title(line.data[5:]) + self.dbase.commit_source(source, self.trans) + elif key[0:4] == "NOTE": + self.__skip_subordinate_levels(1) + else: + self.__not_recognized(1) - def parse_level(self, state, func_map, default): - """ - Loops trough the current GEDCOM level level, calling the appropriate functions - associated with the TOKEN. If no matching function for the token is found, the - default function is called instead. - """ - while True: - line = self.get_next() - if line.level < state.level: - self.backoff = True - return - else: - func = func_map.get(line.token, default) - if self.debug: - print line, func - func(line, state) + def __parse_level(self, state, __map, default): + """ + Loops trough the current GEDCOM level level, calling the appropriate functions + associated with the TOKEN. If no matching function for the token is found, the + default function is called instead. + """ + while True: + line = self.__get_next_line() + if line.level < state.level: + self.backoff = True + return + else: + func = __map.get(line.token, default) + if self.debug: + print line, func + func(line, state) - def func_undefined(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ -# import traceback -# traceback.print_stack() -# print line -# sys.exit(1) - self.not_recognized(state.level+1) + def __undefined(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ +# import traceback +# traceback.print_stack() +# print line +# sys.exit(1) + self.__not_recognized(state.level+1) #---------------------------------------------------------------------- # # INDI parsing # #---------------------------------------------------------------------- - def parse_indi(self, line): - """ - Handling of the GEDCOM INDI tag and all lines subordinate to the current - line. + def __parse_indi(self, line): + """ + Handling of the GEDCOM INDI tag and all lines subordinate to the current + line. - n @XREF:INDI@ INDI {1:1} - +1 RESN {0:1} - +1 <> {0:M} - +1 SEX {0:1} - +1 <> {0:M} - +1 <> {0:M} - +1 <> {0:M} - +1 <> {0:M} - +1 <> {0:M} - +1 SUBM @@ {0:M} - +1 <> {0:M} - +1 ALIA @@ {0:M} - +1 ANCI @@ {0:M} - +1 DESI @@ {0:M} - +1 <> {0:M} - +1 <> {0:M} - +1 <> {0:M} - +1 RFN {0:1} - +1 AFN {0:1} - +1 REFN {0:M} - +2 TYPE {0:1} - +1 RIN {0:1} - +1 <> {0:1} - """ + n @XREF:INDI@ INDI {1:1} + +1 RESN {0:1} + +1 <> {0:M} + +1 SEX {0:1} + +1 <> {0:M} + +1 <> {0:M} + +1 <> {0:M} + +1 <> {0:M} + +1 <> {0:M} + +1 SUBM @@ {0:M} + +1 <> {0:M} + +1 ALIA @@ {0:M} + +1 ANCI @@ {0:M} + +1 DESI @@ {0:M} + +1 <> {0:M} + +1 <> {0:M} + +1 <> {0:M} + +1 RFN {0:1} + +1 AFN {0:1} + +1 REFN {0:M} + +2 TYPE {0:1} + +1 RIN {0:1} + +1 <> {0:1} + """ - # find the person - self.person = self.find_or_create_person(self.pid_map[line.token_text]) - self.added.add(self.person.handle) + # find the person + self.person = self.__find_or_create_person(self.pid_map[line.token_text]) + self.added.add(self.person.handle) - # set up the state for the parsing - state = GedcomUtils.CurrentState(person=self.person, level=1) + # set up the state for the parsing + state = GedcomUtils.CurrentState(person=self.person, level=1) # Ancestry.com GEDCOM files are massively broken, not providing # the FAMC and FAMS values for a person if self.is_ancestry_com: self.map_ancestry_com(line.token_text.strip()) - # do the actual parsing - self.parse_level(state, self.indi_parse_tbl, self.func_person_event) + # do the actual parsing + self.__parse_level(state, self.indi_parse_tbl, self.__person_event) - # Add the default reference if no source has found - self.add_default_source(self.person) + # Add the default reference if no source has found + self.add_default_source(self.person) - # commit the person to the database - if self.person.change: - self.dbase.commit_person(self.person, self.trans, - change_time=state.person.change) - else: - self.dbase.commit_person(self.person, self.trans) - del self.person + # commit the person to the database + if self.person.change: + self.dbase.commit_person(self.person, self.trans, + change_time=state.person.change) + else: + self.dbase.commit_person(self.person, self.trans) + del self.person - def func_person_sour(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - source_ref = self.handle_source(line, state.level+1) - state.person.add_source_reference(source_ref) + def __person_sour(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + source_ref = self.handle_source(line, state.level+1) + state.person.add_source_reference(source_ref) - def func_person_refn(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if INT_RE.match(line.data): - try: - self.refn[state.person.handle] = int(line.data) - except: - return + def __person_refn(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if INT_RE.match(line.data): + try: + self.refn[state.person.handle] = int(line.data) + except: + return - def func_person_attr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type((RelLib.AttributeType.CUSTOM, line.token_text)) - attr.set_value(line.data) - state.person.add_attribute(attr) + def __person_attr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type((RelLib.AttributeType.CUSTOM, line.token_text)) + attr.set_value(line.data) + state.person.add_attribute(attr) - def func_person_event(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.CUSTOM, - self.event_parse_tbl, line.data) - state.person.add_event_ref(event_ref) + def __person_event(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.CUSTOM, + self.event_parse_tbl, line.data) + state.person.add_event_ref(event_ref) - def skip_record(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(2) + def __skip_record(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(2) - def func_person_chan(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_change(line, state.person, state.level+1) - - def func_person_resn(self, line, state): - """ - Parses the RESN tag, adding it as an attribute. + def __person_chan(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_change(line, state.person, state.level+1) + + def __person_resn(self, line, state): + """ + Parses the RESN tag, adding it as an attribute. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type((RelLib.AttributeType.CUSTOM, 'RESN')) - state.person.add_attribute(attr) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type((RelLib.AttributeType.CUSTOM, 'RESN')) + state.person.add_attribute(attr) - def func_person_alt_name(self, line, state): - """ - Parse a altername name, usually indicated by a AKA or _AKA - tag. This is not valid GEDCOM, but several programs will add - this just to make life interesting. Odd, since GEDCOM supports - multiple NAME indicators, which is the correct way of handling - multiple names. + def __person_alt_name(self, line, state): + """ + Parse a altername name, usually indicated by a AKA or _AKA + tag. This is not valid GEDCOM, but several programs will add + this just to make life interesting. Odd, since GEDCOM supports + multiple NAME indicators, which is the correct way of handling + multiple names. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - name = GedcomUtils.parse_name_personal(line.data) - name.set_type(RelLib.NameType.AKA) - state.person.add_alternate_name(name) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + name = GedcomUtils.parse_name_personal(line.data) + name.set_type(RelLib.NameType.AKA) + state.person.add_alternate_name(name) - # Create a new state, and parse the remainder of the NAME level - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.name = name - sub_state.level = 2 + # Create a new state, and parse the remainder of the NAME level + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.name = name + sub_state.level = 2 - self.parse_level(sub_state, self.name_parse_tbl, self.func_undefined) + self.__parse_level(sub_state, self.name_parse_tbl, self.__undefined) - def func_person_object(self, line, state): - """ - Currently, the embedded form is not supported - - Embedded form - - > n OBJE @@ {1:1} + def __person_object(self, line, state): + """ + Currently, the embedded form is not supported + + Embedded form + + > n OBJE @@ {1:1} - Linked form - - > n OBJE {1:1} - > +1 FORM {1:1} - > +1 TITL {0:1} - > +1 FILE {1:1} - > +1 <> {0:M} + Linked form + + > n OBJE {1:1} + > +1 FORM {1:1} + > +1 TITL {0:1} + > +1 FILE {1:1} + > +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - ref = RelLib.MediaRef() - handle = self.find_object_handle(line.data[1:-1]) - ref.set_reference_handle(handle) - state.person.add_media_reference(ref) - else: - (form, filename, title, note) = self.func_obje(state.level+1) - self.build_media_object(state.person, form, filename, title, note) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + ref = RelLib.MediaRef() + handle = self.__find_object_handle(line.data[1:-1]) + ref.set_reference_handle(handle) + state.person.add_media_reference(ref) + else: + (form, filename, title, note) = self.__obje(state.level+1) + self.build_media_object(state.person, form, filename, title, note) - def func_person_name(self, line, state): - """ - Parsers the NAME token in a GEDCOM file. The text is in the format - of (according to the GEDCOM Spec): - > |//|//|//|// - We have encountered some variations that use: - > / + def __person_name(self, line, state): + """ + Parsers the NAME token in a GEDCOM file. The text is in the format + of (according to the GEDCOM Spec): + > |//|//|//|// + We have encountered some variations that use: + > / - The basic Name structure is: + The basic Name structure is: - n NAME {1:1} - +1 NPFX {0:1} - +1 GIVN {0:1} - +1 NICK {0:1} - +1 SPFX {0:1} - +1 NSFX {0:1} - +1 <> {0:M} - +1 <> {0:M} + n NAME {1:1} + +1 NPFX {0:1} + +1 GIVN {0:1} + +1 NICK {0:1} + +1 SPFX {0:1} + +1 NSFX {0:1} + +1 <> {0:M} + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ - # build a RelLib.Name structure from the text - - name = GedcomUtils.parse_name_personal(line.data) + # build a RelLib.Name structure from the text + + name = GedcomUtils.parse_name_personal(line.data) - # Add the name as the primary name if this is the first one that - # we have encountered for this person. Assume that if this is the - # first name, that it is a birth name. Otherwise, label it as an - # "Also Known As (AKA)". GEDCOM does not seem to have the concept - # of different name types - - if state.name_cnt == 0: - name.set_type(RelLib.NameType.BIRTH) - state.person.set_primary_name(name) - else: - name.set_type(RelLib.NameType.AKA) - state.person.add_alternate_name(name) - state.name_cnt += 1 + # Add the name as the primary name if this is the first one that + # we have encountered for this person. Assume that if this is the + # first name, that it is a birth name. Otherwise, label it as an + # "Also Known As (AKA)". GEDCOM does not seem to have the concept + # of different name types + + if state.name_cnt == 0: + name.set_type(RelLib.NameType.BIRTH) + state.person.set_primary_name(name) + else: + name.set_type(RelLib.NameType.AKA) + state.person.add_alternate_name(name) + state.name_cnt += 1 - # Create a new state, and parse the remainder of the NAME level - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.name = name - sub_state.level = state.level+1 + # Create a new state, and parse the remainder of the NAME level + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.name = name + sub_state.level = state.level+1 - self.parse_level(sub_state, self.name_parse_tbl, self.func_undefined) + self.__parse_level(sub_state, self.name_parse_tbl, self.__undefined) - def func_person_sex(self, line, state): - """ - Parses the SEX line of a GEDCOM file. It has the format of: + def __person_sex(self, line, state): + """ + Parses the SEX line of a GEDCOM file. It has the format of: - +1 SEX {0:1} + +1 SEX {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.person.set_gender(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.person.set_gender(line.data) - def func_person_even(self, line, state): - """ - Parses the custom EVEN tag, which has the format of: + def __person_even(self, line, state): + """ + Parses the custom EVEN tag, which has the format of: - n <> {1:1} - +1 <> {0:1} p.* + n <> {1:1} + +1 <> {0:1} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.CUSTOM, - self.event_parse_tbl, line.data) - state.person.add_event_ref(event_ref) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.CUSTOM, + self.event_parse_tbl, line.data) + state.person.add_event_ref(event_ref) - def func_person_std_event(self, line, state): - """ - Parses GEDCOM event types that map to a GRAMPS standard type. Additional - parsing required is for the event detail: + def __person_std_event(self, line, state): + """ + Parses GEDCOM event types that map to a GRAMPS standard type. Additional + parsing required is for the event detail: - +1 <> {0:1} p.* + +1 <> {0:1} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ - event = line.data + event = line.data event.set_gramps_id(self.emapper.find_next()) - event_ref = RelLib.EventRef() - self.dbase.add_event(event, self.trans) - - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level+1 - sub_state.event = event - sub_state.event_ref = event_ref - - self.parse_level(sub_state, self.event_parse_tbl, self.func_undefined) - - person_event_name(event, state.person) - self.dbase.commit_event(event, self.trans) - event_ref.ref = event.handle - state.person.add_event_ref(event_ref) - - def func_person_reli(self, line, state): - """ - Parses the RELI tag. - - n RELI [Y|] {1:1} - +1 <> {0:1} p.* - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.RELIGION, - self.event_parse_tbl, line.data) - state.person.add_event_ref(event_ref) - - def func_person_birt(self, line, state): - """ - Parses GEDCOM BIRT tag into a GRAMPS birth event. Additional work - must be done, since additional handling must be done by GRAMPS to set this up - as a birth reference event. - - n BIRT [Y|] {1:1} - +1 <> {0:1} p.* - +1 FAMC @@ {0:1} p.* - - I'm not sure what value the FAMC actually offers here, since - the FAMC record should handle this. Why it is a valid sub value - is beyond me. - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.BIRTH, - self.event_parse_tbl, line.data) - if state.person.get_birth_ref(): - state.person.add_event_ref(event_ref) - else: - state.person.set_birth_ref(event_ref) - - def func_person_adop(self, line, state): - """ - Parses GEDCOM ADOP tag, subordinate to the INDI tag. Additinal tags - are needed by the tag, so we pass a different function map. - - n ADOP [Y|] {1:1} - +1 <> {0:1} p.* - +1 FAMC @@ {0:1} p.* - +2 ADOP {0:1} - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.ADOPT, - self.adopt_parse_tbl, line.data) - state.person.add_event_ref(event_ref) - - def func_person_deat(self, line, state): - """ - Parses GEDCOM DEAT tag into a GRAMPS birth event. Additional work - must be done, since additional handling must be done by GRAMPS to set this up - as a death reference event. - - n DEAT [Y|] {1:1} - +1 <> {0:1} p.* - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event_ref = self._build_event_pair(state, RelLib.EventType.DEATH, - self.event_parse_tbl, line.data) - if state.person.get_death_ref(): - state.person.add_event_ref(event_ref) - else: - state.person.set_death_ref(event_ref) - - def func_person_note(self, line, state): - """ - Parses a note associated with the person - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.person, 1) - - def func_person_rnote(self, line, state): - """ - Parses a note associated with the person - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.person, 1) - - def func_person_addr(self, line, state): - """ - Parses the Address structure - - n ADDR {0:1} - +1 CONT {0:M} - +1 ADR1 {0:1} - +1 ADR2 {0:1} - +1 CITY {0:1} - +1 STAE {0:1} - +1 POST {0:1} - +1 CTRY {0:1} - n PHON {0:3} - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr = RelLib.Address() - state.addr.set_street(line.data) - state.person.add_address(state.addr) - self.parse_level(state, self.parse_addr_tbl, self.func_ignore) - - def func_person_phon(self, line, state): - """ - n PHON {0:3} - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - addr = RelLib.Address() - addr.set_street("Unknown") - addr.set_phone(line.data) - state.person.add_address(addr) - - def func_person_titl(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event = RelLib.Event() - event_ref = RelLib.EventRef() - event.set_gramps_id(self.emapper.find_next()) - event.set_type(RelLib.EventType.NOB_TITLE) - event.set_description(line.data) - - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level+1 - sub_state.event = event - sub_state.event_ref = event_ref - - self.parse_level(sub_state, self.event_parse_tbl, self.func_undefined) - - person_event_name(event, state.person) - self.dbase.add_event(event, self.trans) - event_ref.ref = event.handle - state.person.add_event_ref(event_ref) - - def func_person_attr_plac(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.attr.get_value() == "": - state.attr.set_value(line.data) - - def func_name_type(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data == "_OTHN": - state.name.set_type(RelLib.NameType.AKA) - else: - state.name.set_type((RelLib.NameType.CUSTOM,line.data)) - - def func_name_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.name, state.level+1) - - def func_name_alia(self, line, state): - """ - The ALIA tag is supposed to cross reference another person. - However, we do not support this. - - Some systems use the ALIA tag as an alternate NAME tag, which - is not legal in GEDCOM, but oddly enough, is easy to support. - """ - if line.data[0] == '@': - aka = GedcomUtils.parse_name_personal(line.data) - state.person.add_alternate_name(aka) - - def func_name_npfx(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.name.set_title(line.data.strip()) - self.skip_subordinate_levels(state.level+1) - - def func_name_givn(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.name.set_first_name(line.data.strip()) - self.skip_subordinate_levels(state.level+1) - - def func_name_spfx(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.name.set_surname_prefix(line.data.strip()) - self.skip_subordinate_levels(state.level+1) - - def func_name_surn(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.name.set_surname(line.data.strip()) - self.skip_subordinate_levels(state.level+1) - - def func_name_marnm(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - text = line.data.strip() - data = text.split() - if len(data) == 1: - name = RelLib.Name(state.person.primary_name) - name.set_surname(data[0].strip()) - name.set_type(RelLib.NameType.MARRIED) - state.person.add_alternate_name(name) - elif len(data) > 1: - name = GedcomUtils.parse_name_personal(text) - name.set_type(RelLib.NameType.MARRIED) - state.person.add_alternate_name(name) - - def func_name_nsfx(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.name.get_suffix() == "": - state.name.set_suffix(line.data) - self.skip_subordinate_levels(state.level+1) - - def func_name_nick(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.NICKNAME) - attr.set_value(line.data) - state.person.add_attribute(attr) - self.skip_subordinate_levels(state.level+1) - - def func_name_aka(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - lname = line.data.split() - name_len = len(lname) - if name_len == 1: - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.NICKNAME) - attr.set_value(line.data) - state.person.add_attribute(attr) - else: - name = RelLib.Name() - name.set_surname(lname[-1].strip()) - name.set_first_name(' '.join(lname[0:name_len-1])) - state.person.add_alternate_name(name) - - def func_name_sour(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sref = self.handle_source(line, state.level+1) - state.name.add_source_reference(sref) - - def func_person_resi(self, line, state): - """ - The RESI tag follows the EVENT_DETAIL structure, which is: - - n TYPE {0:1} - n DATE {0:1} - n <> {0:1} - n <> {0:1} - n AGE {0:1} - n AGNC {0:1} - n CAUS {0:1} - n <> {0:M} - n <> {0:M} - n <> {0:M} - - Currently, the TYPE, AGE, CAUSE, STAT, and other tags which - do not apply to an address are ignored. - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - - addr = RelLib.Address() - - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level+1 - sub_state.addr = addr - sub_state.person.add_address(addr) - - self.parse_level(sub_state, self.resi_parse_tbl, self.func_undefined) - - def func_person_resi_date(self, line, state): - """ - Sets the date on the address associated with and Address. - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_date_object(line.data) - - def func_person_resi_addr(self, line, state): - """ - Parses the ADDR line of a RESI tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_street(line.data) - - sub_state = GedcomUtils.CurrentState() - sub_state.addr = state.addr - sub_state.level = state.level + 1 - sub_state.person = state.person - self.parse_level(sub_state, self.parse_addr_tbl, self.func_ignore) - - def func_person_resi_sour(self, line, state): - """ - Parses the source connected to a RESI tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.add_source_reference(self.handle_source(line, state.level+1)) - - def func_person_resi_plac(self, line, state): - """ - Parses the PLAC tag connected to a RESI tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_street(line.data) - self.parse_level(state, self.parse_addr_tbl, self.func_ignore) - - def func_person_resi_phon(self, line, state): - """ - Parses the source connected to a PHON tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.addr.get_street() == "": - state.addr.set_street("Unknown") - state.addr.set_phone(line.data) - - def func_person_resi_note(self, line, state): - """ - Parses the NOTE connected to a RESI tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.addr, state.level+1) - - def func_ignore(self, line, state): - """ - Ignores an unsupported tag - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) - - def func_person_std_attr(self, line, state): - """ - Parses an TOKEN that GRAMPS recognizes as an Attribute - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.attr = line.data - sub_state.level = state.level+1 - state.person.add_attribute(sub_state.attr) - self.parse_level(sub_state, self.person_attr_parse_tbl, - self.func_ignore) - - def func_person_bapl(self, line, state): - """ - Parses an BAPL TOKEN, producing a GRAMPS LdsOrd instance - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.build_lds_ord(state, RelLib.LdsOrd.BAPTISM) - - def func_person_conl(self, line, state): - """ - Parses an CONL TOKEN, producing a GRAMPS LdsOrd instance - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.build_lds_ord(state, RelLib.LdsOrd.CONFIRMATION) - - def func_person_endl(self, line, state): - """ - Parses an ENDL TOKEN, producing a GRAMPS LdsOrd instance - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.build_lds_ord(state, RelLib.LdsOrd.ENDOWMENT) - - def func_person_slgc(self, line, state): - """ - Parses an SLGC TOKEN, producing a GRAMPS LdsOrd instance - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.build_lds_ord(state, RelLib.LdsOrd.SEAL_TO_PARENTS) + event_ref = RelLib.EventRef() + self.dbase.add_event(event, self.trans) + + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level+1 + sub_state.event = event + sub_state.event_ref = event_ref + + self.__parse_level(sub_state, self.event_parse_tbl, self.__undefined) + + person_event_name(event, state.person) + self.dbase.commit_event(event, self.trans) + event_ref.ref = event.handle + state.person.add_event_ref(event_ref) + + def __person_reli(self, line, state): + """ + Parses the RELI tag. + + n RELI [Y|] {1:1} + +1 <> {0:1} p.* + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.RELIGION, + self.event_parse_tbl, line.data) + state.person.add_event_ref(event_ref) + + def __person_birt(self, line, state): + """ + Parses GEDCOM BIRT tag into a GRAMPS birth event. Additional work + must be done, since additional handling must be done by GRAMPS to set this up + as a birth reference event. + + n BIRT [Y|] {1:1} + +1 <> {0:1} p.* + +1 FAMC @@ {0:1} p.* + + I'm not sure what value the FAMC actually offers here, since + the FAMC record should handle this. Why it is a valid sub value + is beyond me. + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.BIRTH, + self.event_parse_tbl, line.data) + if state.person.get_birth_ref(): + state.person.add_event_ref(event_ref) + else: + state.person.set_birth_ref(event_ref) + + def __person_adop(self, line, state): + """ + Parses GEDCOM ADOP tag, subordinate to the INDI tag. Additinal tags + are needed by the tag, so we pass a different function map. + + n ADOP [Y|] {1:1} + +1 <> {0:1} p.* + +1 FAMC @@ {0:1} p.* + +2 ADOP {0:1} + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.ADOPT, + self.adopt_parse_tbl, line.data) + state.person.add_event_ref(event_ref) + + def __person_deat(self, line, state): + """ + Parses GEDCOM DEAT tag into a GRAMPS birth event. Additional work + must be done, since additional handling must be done by GRAMPS to set this up + as a death reference event. + + n DEAT [Y|] {1:1} + +1 <> {0:1} p.* + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event_ref = self.__build_event_pair(state, RelLib.EventType.DEATH, + self.event_parse_tbl, line.data) + if state.person.get_death_ref(): + state.person.add_event_ref(event_ref) + else: + state.person.set_death_ref(event_ref) + + def __person_note(self, line, state): + """ + Parses a note associated with the person + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.person, 1) + + def __person_rnote(self, line, state): + """ + Parses a note associated with the person + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.person, 1) + + def __person_addr(self, line, state): + """ + Parses the Address structure + + n ADDR {0:1} + +1 CONT {0:M} + +1 ADR1 {0:1} + +1 ADR2 {0:1} + +1 CITY {0:1} + +1 STAE {0:1} + +1 POST {0:1} + +1 CTRY {0:1} + n PHON {0:3} + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr = RelLib.Address() + state.addr.set_street(line.data) + state.person.add_address(state.addr) + self.__parse_level(state, self.parse_addr_tbl, self.__ignore) + + def __person_phon(self, line, state): + """ + n PHON {0:3} + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + addr = RelLib.Address() + addr.set_street("Unknown") + addr.set_phone(line.data) + state.person.add_address(addr) + + def __person_titl(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event = RelLib.Event() + event_ref = RelLib.EventRef() + event.set_gramps_id(self.emapper.find_next()) + event.set_type(RelLib.EventType.NOB_TITLE) + event.set_description(line.data) + + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level+1 + sub_state.event = event + sub_state.event_ref = event_ref + + self.__parse_level(sub_state, self.event_parse_tbl, self.__undefined) + + person_event_name(event, state.person) + self.dbase.add_event(event, self.trans) + event_ref.ref = event.handle + state.person.add_event_ref(event_ref) + + def __person_attr_plac(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.attr.get_value() == "": + state.attr.set_value(line.data) + + def __name_type(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data == "_OTHN": + state.name.set_type(RelLib.NameType.AKA) + else: + state.name.set_type((RelLib.NameType.CUSTOM, line.data)) + + def __name_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.name, state.level+1) + + def __name_alia(self, line, state): + """ + The ALIA tag is supposed to cross reference another person. + However, we do not support this. + + Some systems use the ALIA tag as an alternate NAME tag, which + is not legal in GEDCOM, but oddly enough, is easy to support. + """ + if line.data[0] == '@': + aka = GedcomUtils.parse_name_personal(line.data) + state.person.add_alternate_name(aka) + + def __name_npfx(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.name.set_title(line.data.strip()) + self.__skip_subordinate_levels(state.level+1) + + def __name_givn(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.name.set_first_name(line.data.strip()) + self.__skip_subordinate_levels(state.level+1) + + def __name_spfx(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.name.set_surname_prefix(line.data.strip()) + self.__skip_subordinate_levels(state.level+1) + + def __name_surn(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.name.set_surname(line.data.strip()) + self.__skip_subordinate_levels(state.level+1) + + def __name_marnm(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + text = line.data.strip() + data = text.split() + if len(data) == 1: + name = RelLib.Name(state.person.primary_name) + name.set_surname(data[0].strip()) + name.set_type(RelLib.NameType.MARRIED) + state.person.add_alternate_name(name) + elif len(data) > 1: + name = GedcomUtils.parse_name_personal(text) + name.set_type(RelLib.NameType.MARRIED) + state.person.add_alternate_name(name) + + def __name_nsfx(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.name.get_suffix() == "": + state.name.set_suffix(line.data) + self.__skip_subordinate_levels(state.level+1) + + def __name_nick(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.NICKNAME) + attr.set_value(line.data) + state.person.add_attribute(attr) + self.__skip_subordinate_levels(state.level+1) + + def __name_aka(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + lname = line.data.split() + name_len = len(lname) + if name_len == 1: + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.NICKNAME) + attr.set_value(line.data) + state.person.add_attribute(attr) + else: + name = RelLib.Name() + name.set_surname(lname[-1].strip()) + name.set_first_name(' '.join(lname[0:name_len-1])) + state.person.add_alternate_name(name) + + def __name_sour(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sref = self.handle_source(line, state.level+1) + state.name.add_source_reference(sref) + + def __person_resi(self, line, state): + """ + The RESI tag follows the EVENT_DETAIL structure, which is: + + n TYPE {0:1} + n DATE {0:1} + n <> {0:1} + n <> {0:1} + n AGE {0:1} + n AGNC {0:1} + n CAUS {0:1} + n <> {0:M} + n <> {0:M} + n <> {0:M} + + Currently, the TYPE, AGE, CAUSE, STAT, and other tags which + do not apply to an address are ignored. + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + + addr = RelLib.Address() + + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level+1 + sub_state.addr = addr + sub_state.person.add_address(addr) + + self.__parse_level(sub_state, self.resi_parse_tbl, self.__undefined) + + def __person_resi_date(self, line, state): + """ + Sets the date on the address associated with and Address. + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_date_object(line.data) + + def __person_resi_addr(self, line, state): + """ + Parses the ADDR line of a RESI tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_street(line.data) + + sub_state = GedcomUtils.CurrentState() + sub_state.addr = state.addr + sub_state.level = state.level + 1 + sub_state.person = state.person + self.__parse_level(sub_state, self.parse_addr_tbl, self.__ignore) + + def __person_resi_sour(self, line, state): + """ + Parses the source connected to a RESI tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.add_source_reference(self.handle_source(line, state.level+1)) + + def __person_resi_plac(self, line, state): + """ + Parses the PLAC tag connected to a RESI tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_street(line.data) + self.__parse_level(state, self.parse_addr_tbl, self.__ignore) + + def __person_resi_phon(self, line, state): + """ + Parses the source connected to a PHON tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.addr.get_street() == "": + state.addr.set_street("Unknown") + state.addr.set_phone(line.data) + + def __person_resi_note(self, line, state): + """ + Parses the NOTE connected to a RESI tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.addr, state.level+1) + + def __ignore(self, line, state): + """ + Ignores an unsupported tag + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) + + def __person_std_attr(self, line, state): + """ + Parses an TOKEN that GRAMPS recognizes as an Attribute + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.attr = line.data + sub_state.level = state.level+1 + state.person.add_attribute(sub_state.attr) + self.__parse_level(sub_state, self.person_attr_parse_tbl, + self.__ignore) + + def __person_bapl(self, line, state): + """ + Parses an BAPL TOKEN, producing a GRAMPS LdsOrd instance + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.build_lds_ord(state, RelLib.LdsOrd.BAPTISM) + + def __person_conl(self, line, state): + """ + Parses an CONL TOKEN, producing a GRAMPS LdsOrd instance + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.build_lds_ord(state, RelLib.LdsOrd.CONFIRMATION) + + def __person_endl(self, line, state): + """ + Parses an ENDL TOKEN, producing a GRAMPS LdsOrd instance + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.build_lds_ord(state, RelLib.LdsOrd.ENDOWMENT) + + def __person_slgc(self, line, state): + """ + Parses an SLGC TOKEN, producing a GRAMPS LdsOrd instance + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.build_lds_ord(state, RelLib.LdsOrd.SEAL_TO_PARENTS) def build_lds_ord(self, state, lds_type): - """ - Parses an LDS ordinance, using the type passed to the routine + """ + Parses an LDS ordinance, using the type passed to the routine - @param state: The current state - @type state: CurrentState - @param lds_type: The type of the LDS ordinance - @type line: LdsOrd type - """ - sub_state = GedcomUtils.CurrentState() - sub_state.level = state.level + 1 - sub_state.lds_ord = RelLib.LdsOrd() - sub_state.lds_ord.set_type(lds_type) - sub_state.place = None - sub_state.place_fields = GedcomUtils.PlaceParser() - sub_state.person = state.person - state.person.lds_ord_list.append(sub_state.lds_ord) + @param state: The current state + @type state: CurrentState + @param lds_type: The type of the LDS ordinance + @type line: LdsOrd type + """ + sub_state = GedcomUtils.CurrentState() + sub_state.level = state.level + 1 + sub_state.lds_ord = RelLib.LdsOrd() + sub_state.lds_ord.set_type(lds_type) + sub_state.place = None + sub_state.place_fields = GedcomUtils.PlaceParser() + sub_state.person = state.person + state.person.lds_ord_list.append(sub_state.lds_ord) - self.parse_level(sub_state, self.lds_parse_tbl, self.func_ignore) + self.__parse_level(sub_state, self.lds_parse_tbl, self.__ignore) - if sub_state.place: - sub_state.place_fields.load_place(sub_state.place, - sub_state.place.get_title()) + if sub_state.place: + sub_state.place_fields.load_place(sub_state.place, + sub_state.place.get_title()) - def func_lds_temple(self, line, state): - """ - Parses the TEMP tag, looking up the code for a match. + def __lds_temple(self, line, state): + """ + Parses the TEMP tag, looking up the code for a match. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - value = self.extract_temple(line) - if value: - state.lds_ord.set_temple(value) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + value = self.extract_temple(line) + if value: + state.lds_ord.set_temple(value) - def func_lds_date(self, line, state): - """ - Parses the DATE tag for the LdsOrd + def __lds_date(self, line, state): + """ + Parses the DATE tag for the LdsOrd - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.lds_ord.set_date_object(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.lds_ord.set_date_object(line.data) - def func_lds_famc(self, line, state): - """ - Parses the FAMC tag attached to the LdsOrd + def __lds_famc(self, line, state): + """ + Parses the FAMC tag attached to the LdsOrd - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - gid = self.fid_map[line.data] - state.lds_ord.set_family_handle(self.find_family_handle(gid)) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + gid = self.fid_map[line.data] + state.lds_ord.set_family_handle(self.__find_family_handle(gid)) - def func_lds_form(self, line, state): - """ - Parses the FORM tag thate defines the place structure for a place. This - tag, if found, will override any global place structure. + def __lds_form(self, line, state): + """ + Parses the FORM tag thate defines the place structure for a place. This + tag, if found, will override any global place structure. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.pf = GedcomUtils.PlaceParser(line) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.pf = GedcomUtils.PlaceParser(line) - def func_lds_plac(self, line, state): - """ - Parses the PLAC tag attached to the LdsOrd. Create a new place if - needed and set the title. + def __lds_plac(self, line, state): + """ + Parses the PLAC tag attached to the LdsOrd. Create a new place if + needed and set the title. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - try: - state.place = self.find_or_create_place(line.data) - state.place.set_title(line.data) - state.lds_ord.set_place_handle(state.place.handle) - except NameError: - return + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + try: + state.place = self.__find_or_create_place(line.data) + state.place.set_title(line.data) + state.lds_ord.set_place_handle(state.place.handle) + except NameError: + return - def func_lds_sour(self, line, state): - """ - Parses the SOUR tag attached to the LdsOrd. + def __lds_sour(self, line, state): + """ + Parses the SOUR tag attached to the LdsOrd. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - srcref = self.handle_source(line, state.level+1) - state.lds_ord.add_source_reference(srcref) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + srcref = self.handle_source(line, state.level+1) + state.lds_ord.add_source_reference(srcref) - def func_lds_note(self, line, state): - """ - Parses the NOTE tag attached to the LdsOrd. + def __lds_note(self, line, state): + """ + Parses the NOTE tag attached to the LdsOrd. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.lds_ord, state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.lds_ord, state.level+1) - def func_lds_stat(self, line, state): - """ - Parses the STAT (status) tag attached to the LdsOrd. + def __lds_stat(self, line, state): + """ + Parses the STAT (status) tag attached to the LdsOrd. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - status = lds_status.get(line.data, RelLib.LdsOrd.STATUS_NONE) - state.lds_ord.set_status(status) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + status = lds_status.get(line.data, RelLib.LdsOrd.STATUS_NONE) + state.lds_ord.set_status(status) - def func_person_famc(self, line, state): - """ - Handles the parsing of the FAMC line, which indicates which family the - person is a child of. + def __person_famc(self, line, state): + """ + Handles the parsing of the FAMC line, which indicates which family the + person is a child of. - n FAMC @@ {1:1} - +1 PEDI {0:M} p.* - +1 <> {0:M} p.* + n FAMC @@ {1:1} + +1 PEDI {0:M} p.* + +1 <> {0:M} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level + 1 - sub_state.ftype = None - sub_state.primary = False + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level + 1 + sub_state.ftype = None + sub_state.primary = False - gid = self.fid_map[line.data] - handle = self.find_family_handle(gid) + gid = self.fid_map[line.data] + handle = self.__find_family_handle(gid) - self.parse_level(sub_state, self.famc_parse_tbl, self.func_undefined) + self.__parse_level(sub_state, self.famc_parse_tbl, self.__undefined) - # if the handle is not already in the person's parent family list, we - # need to add it to thie list. + # if the handle is not already in the person's parent family list, we + # need to add it to thie list. - flist = [fam[0] for fam in state.person.get_parent_family_handle_list()] - if not handle in flist: - if sub_state.ftype and int(sub_state.ftype) in RELATION_TYPES: - state.person.add_parent_family_handle(handle) - else: - if state.person.get_main_parents_family_handle() == handle: - state.person.set_main_parent_family_handle(None) - state.person.add_parent_family_handle(handle) + flist = [fam[0] for fam in state.person.get_parent_family_handle_list()] + if not handle in flist: + if sub_state.ftype and int(sub_state.ftype) in RELATION_TYPES: + state.person.add_parent_family_handle(handle) + else: + if state.person.get_main_parents_family_handle() == handle: + state.person.set_main_parent_family_handle(None) + state.person.add_parent_family_handle(handle) - # search childrefs - family = self.dbase.find_family_from_handle(handle, self.trans) - family.set_gramps_id(gid) - - for ref in family.get_child_ref_list(): - if ref.ref == state.person.handle: - if sub_state.ftype: - ref.set_mother_relation(sub_state.ftype) - ref.set_father_relation(sub_state.ftype) - break - else: - ref = RelLib.ChildRef() - ref.ref = state.person.handle - if sub_state.ftype: - ref.set_mother_relation(sub_state.ftype) - ref.set_father_relation(sub_state.ftype) - family.add_child_ref(ref) - self.dbase.commit_family(family, self.trans) + # search childrefs + family = self.dbase.find_family_from_handle(handle, self.trans) + family.set_gramps_id(gid) + + for ref in family.get_child_ref_list(): + if ref.ref == state.person.handle: + if sub_state.ftype: + ref.set_mother_relation(sub_state.ftype) + ref.set_father_relation(sub_state.ftype) + break + else: + ref = RelLib.ChildRef() + ref.ref = state.person.handle + if sub_state.ftype: + ref.set_mother_relation(sub_state.ftype) + ref.set_father_relation(sub_state.ftype) + family.add_child_ref(ref) + self.dbase.commit_family(family, self.trans) - def func_person_famc_pedi(self, line, state): - """ - Parses the PEDI tag attached to a INDI.FAMC record. No values are set - at this point, because we have to do some post processing. Instead, we - assign the ftype field of the state variable. We convert the text from - the line to an index into the PEDIGREE_TYPES dictionary, which will map - to the correct ChildTypeRef. + def __person_famc_pedi(self, line, state): + """ + Parses the PEDI tag attached to a INDI.FAMC record. No values are set + at this point, because we have to do some post processing. Instead, we + assign the ftype field of the state variable. We convert the text from + the line to an index into the PEDIGREE_TYPES dictionary, which will map + to the correct ChildTypeRef. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.ftype = PEDIGREE_TYPES.get(line.data.lower(), - RelLib.ChildRefType.UNKNOWN) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.ftype = PEDIGREE_TYPES.get(line.data.lower(), + RelLib.ChildRefType.UNKNOWN) - def func_person_famc_note(self, line, state): - """ - Parses the INDI.FAMC.NOTE tag . + def __person_famc_note(self, line, state): + """ + Parses the INDI.FAMC.NOTE tag . - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.person, state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.person, state.level+1) - def func_person_famc_primary(self, line, state): - """ - Parses the _PRIM tag on an INDI.FAMC tag. This value is stored in - the state record to be used later. + def __person_famc_primary(self, line, state): + """ + Parses the _PRIM tag on an INDI.FAMC tag. This value is stored in + the state record to be used later. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.primary = True + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.primary = True - def func_person_famc_sour(self, line, state): - """ - Parses the SOUR tag on an INDI.FAMC tag. GRAMPS has no corresponding - record on its family relationship, so we add the source to the Person - record. + def __person_famc_sour(self, line, state): + """ + Parses the SOUR tag on an INDI.FAMC tag. GRAMPS has no corresponding + record on its family relationship, so we add the source to the Person + record. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - source_ref = self.handle_source(line, state.level) - state.person.add_source_reference(source_ref) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + source_ref = self.handle_source(line, state.level) + state.person.add_source_reference(source_ref) - def func_person_fams(self, line, state): - """ - Parses the INDI.FAMS record, which indicates the family in which the - person is a spouse. + def __person_fams(self, line, state): + """ + Parses the INDI.FAMS record, which indicates the family in which the + person is a spouse. - n FAMS @@ {1:1} p.* - +1 <> {0:M} p.* + n FAMS @@ {1:1} p.* + +1 <> {0:M} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - handle = self.find_family_handle(self.fid_map[line.data]) - state.person.add_family_handle(handle) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + handle = self.__find_family_handle(self.fid_map[line.data]) + state.person.add_family_handle(handle) - sub_state = GedcomUtils.CurrentState(level=state.level+1) - sub_state.obj = state.person - self.parse_level(sub_state, self.opt_note_tbl, self.func_ignore) + sub_state = GedcomUtils.CurrentState(level=state.level+1) + sub_state.obj = state.person + self.__parse_level(sub_state, self.opt_note_tbl, self.__ignore) - def func_person_asso(self, line, state): - """ - Parse the ASSO tag, add the the referenced person to the person we - are currently parsing. The GEDCOM spec indicates that valid ASSO tag - is: - - n ASSO @@ {0:M} - - And the the sub tags are: - - ASSOCIATION_STRUCTURE:= - +1 TYPE {1:1} - +1 RELA {1:1} - +1 <> {0:M} - +1 <> {0:M} + def __person_asso(self, line, state): + """ + Parse the ASSO tag, add the the referenced person to the person we + are currently parsing. The GEDCOM spec indicates that valid ASSO tag + is: + + n ASSO @@ {0:M} + + And the the sub tags are: + + ASSOCIATION_STRUCTURE:= + +1 TYPE {1:1} + +1 RELA {1:1} + +1 <> {0:M} + +1 <> {0:M} - GRAMPS only supports ASSO records to people, so if the TYPE is - something other than INDI, the record is ignored. + GRAMPS only supports ASSO records to people, so if the TYPE is + something other than INDI, the record is ignored. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ - # find the id and person that we are referencing - handle = self.find_person_handle(self.pid_map[line.data]) + # find the id and person that we are referencing + handle = self.__find_person_handle(self.pid_map[line.data]) - # create a new PersonRef, and assign the handle, add the - # PersonRef to the active person + # create a new PersonRef, and assign the handle, add the + # PersonRef to the active person - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level + 1 - sub_state.ref = RelLib.PersonRef() - sub_state.ref.ref = handle - sub_state.ignore = False + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level + 1 + sub_state.ref = RelLib.PersonRef() + sub_state.ref.ref = handle + sub_state.ignore = False - self.parse_level(sub_state, self.asso_parse_tbl, self.func_ignore) - if not sub_state.ignore: - state.person.add_person_ref(sub_state.ref) + self.__parse_level(sub_state, self.asso_parse_tbl, self.__ignore) + if not sub_state.ignore: + state.person.add_person_ref(sub_state.ref) - def func_person_asso_type(self, line, state): - """ - Parses the INDI.ASSO.TYPE tag. GRAMPS only supports the ASSO tag when - the tag represents an INDI. So if the data is not INDI, we set the ignore - flag, so that we ignore the record. + def __person_asso_type(self, line, state): + """ + Parses the INDI.ASSO.TYPE tag. GRAMPS only supports the ASSO tag when + the tag represents an INDI. So if the data is not INDI, we set the ignore + flag, so that we ignore the record. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data != "INDI": - state.ignore = True + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data != "INDI": + state.ignore = True - def func_person_asso_rela(self, line, state): - """ - Parses the INDI.ASSO.RELA tag. + def __person_asso_rela(self, line, state): + """ + Parses the INDI.ASSO.RELA tag. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.ref.rel = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.ref.rel = line.data - def func_person_asso_sour(self, line, state): - """ - Parses the INDI.ASSO.SOUR tag. + def __person_asso_sour(self, line, state): + """ + Parses the INDI.ASSO.SOUR tag. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.ref.add_source_reference(self.handle_source(line, state.level)) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.ref.add_source_reference(self.handle_source(line, state.level)) - def func_person_asso_note(self, line, state): - """ - Parses the INDI.ASSO.NOTE tag. + def __person_asso_note(self, line, state): + """ + Parses the INDI.ASSO.NOTE tag. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.ref, state.level) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.ref, state.level) #------------------------------------------------------------------- # @@ -2414,1648 +2413,1649 @@ class GedcomParser(UpdateCallback): # #------------------------------------------------------------------- - def parse_fam(self, line): - """ - n @@ FAM {1:1} - +1 <> {0:M} - +1 HUSB @@ {0:1} - +1 WIFE @@ {0:1} - +1 CHIL @@ {0:M} + def __parse_fam(self, line): + """ + n @@ FAM {1:1} + +1 <> {0:M} + +1 HUSB @@ {0:1} + +1 WIFE @@ {0:1} + +1 CHIL @@ {0:M} +1 NCHI {0:1} - +1 SUBM @@ {0:M} + +1 SUBM @@ {0:M} +1 <> {0:M} +1 <> {0:M} +1 <> {0:M} - +1 <> {0:M} + +1 <> {0:M} +1 REFN {0:M} - +1 RIN {0:1} + +1 RIN {0:1} +1 <> {0:1} """ - # create a family - - family = self.find_or_create_family(self.fid_map[line.token_text]) + # create a family + + family = self.__find_or_create_family(self.fid_map[line.token_text]) - # parse the family + # parse the family - state = GedcomUtils.CurrentState(level=1) - state.family = family + state = GedcomUtils.CurrentState(level=1) + state.family = family - self.parse_level(state, self.family_func, self.func_family_even) + self.__parse_level(state, self.family_func, self.__family_even) - # handle addresses attached to families - if state.addr != None: - father_handle = family.get_father_handle() - father = self.dbase.get_person_from_handle(father_handle) - if father: - father.add_address(state.addr) - self.dbase.commit_person(father, self.trans) - mother_handle = family.get_mother_handle() - mother = self.dbase.get_person_from_handle(mother_handle) - if mother: - mother.add_address(state.addr) - self.dbase.commit_person(mother, self.trans) + # handle addresses attached to families + if state.addr != None: + father_handle = family.get_father_handle() + father = self.dbase.get_person_from_handle(father_handle) + if father: + father.add_address(state.addr) + self.dbase.commit_person(father, self.trans) + mother_handle = family.get_mother_handle() + mother = self.dbase.get_person_from_handle(mother_handle) + if mother: + mother.add_address(state.addr) + self.dbase.commit_person(mother, self.trans) - for child_ref in family.get_child_ref_list(): - child_handle = child_ref.ref - child = self.dbase.get_person_from_handle(child_handle) - if child: - child.add_address(state.addr) - self.dbase.commit_person(child, self.trans) + for child_ref in family.get_child_ref_list(): + child_handle = child_ref.ref + child = self.dbase.get_person_from_handle(child_handle) + if child: + child.add_address(state.addr) + self.dbase.commit_person(child, self.trans) - # add default reference if no reference exists - self.add_default_source(family) + # add default reference if no reference exists + self.add_default_source(family) - # commit family to database - if family.change: - self.dbase.commit_family(family, self.trans, - change_time=family.change) - else: - self.dbase.commit_family(family, self.trans) + # commit family to database + if family.change: + self.dbase.commit_family(family, self.trans, + change_time=family.change) + else: + self.dbase.commit_family(family, self.trans) - def func_family_husb(self, line, state): - """ - Parses the husband line of a family + def __family_husb(self, line, state): + """ + Parses the husband line of a family - n HUSB @@ {0:1} + n HUSB @@ {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState """ - handle = self.find_person_handle(self.pid_map[line.data]) - state.family.set_father_handle(handle) + handle = self.__find_person_handle(self.pid_map[line.data]) + state.family.set_father_handle(handle) - def func_family_wife(self, line, state): - """ + def __family_wife(self, line, state): + """ Parses the wife line of a family n WIFE @@ {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState """ - handle = self.find_person_handle(self.pid_map[line.data]) - state.family.set_mother_handle(handle) + handle = self.__find_person_handle(self.pid_map[line.data]) + state.family.set_mother_handle(handle) - def func_family_std_event(self, line, state): - """ - Parses GEDCOM event types that map to a GRAMPS standard type. Additional - parsing required is for the event detail: + def __family_std_event(self, line, state): + """ + Parses GEDCOM event types that map to a GRAMPS standard type. Additional + parsing required is for the event detail: - +1 <> {0:1} p.* + +1 <> {0:1} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event = line.data event.set_gramps_id(self.emapper.find_next()) - event_ref = RelLib.EventRef() - event_ref.set_role(RelLib.EventRoleType.FAMILY) - self.dbase.add_event(event, self.trans) + event_ref = RelLib.EventRef() + event_ref.set_role(RelLib.EventRoleType.FAMILY) + self.dbase.add_event(event, self.trans) - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level+1 - sub_state.event = event - sub_state.event_ref = event_ref + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level+1 + sub_state.event = event + sub_state.event_ref = event_ref - self.parse_level(sub_state, self.event_parse_tbl, self.func_undefined) + self.__parse_level(sub_state, self.event_parse_tbl, self.__undefined) - family_event_name(event, state.family) - self.dbase.commit_event(event, self.trans) - event_ref.ref = event.handle - state.family.add_event_ref(event_ref) + family_event_name(event, state.family) + self.dbase.commit_event(event, self.trans) + event_ref.ref = event.handle + state.family.add_event_ref(event_ref) - def func_family_even(self, line, state): - """ - Parses GEDCOM event types that map to a GRAMPS standard type. Additional - parsing required is for the event detail: + def __family_even(self, line, state): + """ + Parses GEDCOM event types that map to a GRAMPS standard type. Additional + parsing required is for the event detail: - +1 <> {0:1} p.* + +1 <> {0:1} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - event = RelLib.Event() - event_ref = RelLib.EventRef() - event_ref.set_role(RelLib.EventRoleType.FAMILY) - event.set_gramps_id(self.emapper.find_next()) - event.set_type(line.data) - self.dbase.add_event(event, self.trans) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + event = RelLib.Event() + event_ref = RelLib.EventRef() + event_ref.set_role(RelLib.EventRoleType.FAMILY) + event.set_gramps_id(self.emapper.find_next()) + event.set_type(line.data) + self.dbase.add_event(event, self.trans) - sub_state = GedcomUtils.CurrentState() - sub_state.person = state.person - sub_state.level = state.level+1 - sub_state.event = event - sub_state.event_ref = event_ref + sub_state = GedcomUtils.CurrentState() + sub_state.person = state.person + sub_state.level = state.level+1 + sub_state.event = event + sub_state.event_ref = event_ref - self.parse_level(sub_state, self.event_parse_tbl, self.func_undefined) + self.__parse_level(sub_state, self.event_parse_tbl, self.__undefined) - if int(event.get_type()) == RelLib.EventType.MARRIAGE: + if int(event.get_type()) == RelLib.EventType.MARRIAGE: - descr = event.get_description() - if descr == "Civil Union": - state.family.type.set(RelLib.FamilyRelType.CIVIL_UNION) - event.set_description('') - elif descr == "Unmarried": - state.family.type.set(RelLib.FamilyRelType.UNMARRIED) - event.set_description('') - else: - state.family.type.set(RelLib.FamilyRelType.MARRIED) + descr = event.get_description() + if descr == "Civil Union": + state.family.type.set(RelLib.FamilyRelType.CIVIL_UNION) + event.set_description('') + elif descr == "Unmarried": + state.family.type.set(RelLib.FamilyRelType.UNMARRIED) + event.set_description('') + else: + state.family.type.set(RelLib.FamilyRelType.MARRIED) - family_event_name(event, state.family) + family_event_name(event, state.family) - self.dbase.commit_event(event, self.trans) - event_ref.ref = event.handle - state.family.add_event_ref(event_ref) + self.dbase.commit_event(event, self.trans) + event_ref.ref = event.handle + state.family.add_event_ref(event_ref) - def func_family_chil(self, line, state): - """ - Parses the child line of a family + def __family_chil(self, line, state): + """ + Parses the child line of a family - n CHIL @@ {0:1} + n CHIL @@ {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState() - sub_state.family = state.family - sub_state.level = state.level + 1 - sub_state.mrel = None - sub_state.frel = None + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState() + sub_state.family = state.family + sub_state.level = state.level + 1 + sub_state.mrel = None + sub_state.frel = None - self.parse_level(sub_state, self.family_rel_tbl, self.func_ignore) + self.__parse_level(sub_state, self.family_rel_tbl, self.__ignore) - child = self.find_or_create_person(self.pid_map[line.data]) + child = self.__find_or_create_person(self.pid_map[line.data]) - reflist = [ ref for ref in state.family.get_child_ref_list() \ - if ref.ref == child.handle ] + reflist = [ ref for ref in state.family.get_child_ref_list() \ + if ref.ref == child.handle ] - if reflist: - ref = reflist[0] - if sub_state.frel: - ref.set_father_relation(sub_state.frel) - if sub_state.mrel: - ref.set_mother_relation(sub_state.mrel) - else: - ref = RelLib.ChildRef() - ref.ref = child.handle - if sub_state.frel: - ref.set_father_relation(sub_state.frel) - if sub_state.mrel: - ref.set_mother_relation(sub_state.mrel) - state.family.add_child_ref(ref) + if reflist: + ref = reflist[0] + if sub_state.frel: + ref.set_father_relation(sub_state.frel) + if sub_state.mrel: + ref.set_mother_relation(sub_state.mrel) + else: + ref = RelLib.ChildRef() + ref.ref = child.handle + if sub_state.frel: + ref.set_father_relation(sub_state.frel) + if sub_state.mrel: + ref.set_mother_relation(sub_state.mrel) + state.family.add_child_ref(ref) - def func_family_slgs(self, line, state): - """ - n SLGS {1:1} - +1 STAT {0:1} - +1 DATE {0:1} - +1 TEMP {0:1} - +1 PLAC {0:1} - +1 <> {0:M} - +1 <> {0:M} + def __family_slgs(self, line, state): + """ + n SLGS {1:1} + +1 STAT {0:1} + +1 DATE {0:1} + +1 TEMP {0:1} + +1 PLAC {0:1} + +1 <> {0:M} + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState """ - sub_state = GedcomUtils.CurrentState() - sub_state.level = state.level + 1 - sub_state.lds_ord = RelLib.LdsOrd() - sub_state.lds_ord.set_type(RelLib.LdsOrd.SEAL_TO_SPOUSE) - sub_state.place = None - sub_state.family = state.family - sub_state.place_fields = GedcomUtils.PlaceParser() - state.family.lds_ord_list.append(sub_state.lds_ord) + sub_state = GedcomUtils.CurrentState() + sub_state.level = state.level + 1 + sub_state.lds_ord = RelLib.LdsOrd() + sub_state.lds_ord.set_type(RelLib.LdsOrd.SEAL_TO_SPOUSE) + sub_state.place = None + sub_state.family = state.family + sub_state.place_fields = GedcomUtils.PlaceParser() + state.family.lds_ord_list.append(sub_state.lds_ord) - self.parse_level(sub_state, self.lds_parse_tbl, self.func_ignore) + self.__parse_level(sub_state, self.lds_parse_tbl, self.__ignore) - if sub_state.place: - sub_state.place_fields.load_place(sub_state.place, + if sub_state.place: + sub_state.place_fields.load_place(sub_state.place, sub_state.place.get_title()) - def func_family_source(self, line, state): - """ - n SOUR @@ /* pointer to source record */ {1:1} p.* - +1 PAGE {0:1} p.* - +1 EVEN {0:1} p.* - +1 DATA {0:1} - +1 QUAY {0:1} p.* - +1 <> {0:M} p.*,* - +1 <> {0:M} p.* + def __family_source(self, line, state): + """ + n SOUR @@ /* pointer to source record */ {1:1} p.* + +1 PAGE {0:1} p.* + +1 EVEN {0:1} p.* + +1 DATA {0:1} + +1 QUAY {0:1} p.* + +1 <> {0:M} p.*,* + +1 <> {0:M} p.* - | /* Systems not using source records */ - n SOUR {1:1} p.* - +1 [ CONC | CONT ] {0:M} - +1 TEXT {0:M} p.* - +1 <> {0:M} p.* + | /* Systems not using source records */ + n SOUR {1:1} p.* + +1 [ CONC | CONT ] {0:M} + +1 TEXT {0:M} p.* + +1 <> {0:M} p.* - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - source_ref = self.handle_source(line, state.level+1) - state.family.add_source_reference(source_ref) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + source_ref = self.handle_source(line, state.level+1) + state.family.add_source_reference(source_ref) - def func_family_object(self, line, state): - """ - +1 <> {0:M} + def __family_object(self, line, state): + """ + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - self.not_recognized(state.level) - else: - (form, filename, title, note) = self.func_obje(state.level) - self.build_media_object(state.family, form, filename, title, note) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + self.__not_recognized(state.level) + else: + (form, filename, title, note) = self.__obje(state.level) + self.build_media_object(state.family, form, filename, title, note) - def func_family_comm(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - note = line.data - state.family.add_note(note) - self.skip_subordinate_levels(state.level+1) + def __family_comm(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + note = line.data + state.family.add_note(note) + self.__skip_subordinate_levels(state.level+1) - def func_family_note(self, line, state): - """ - +1 <> {0:M} + def __family_note(self, line, state): + """ + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.family, state.level) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.family, state.level) - def func_family_chan(self, line, state): - """ - +1 <> {0:1} + def __family_chan(self, line, state): + """ + +1 <> {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_change(line, state.family, state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_change(line, state.family, state.level+1) - def func_family_addr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr = RelLib.Address() - state.addr.set_street(line.data) - self.parse_level(state, self.parse_addr_tbl, self.func_ignore) + def __family_addr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr = RelLib.Address() + state.addr.set_street(line.data) + self.__parse_level(state, self.parse_addr_tbl, self.__ignore) - def func_family_attr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.family.add_attribute(line.data) + def __family_attr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.family.add_attribute(line.data) - def func_family_cust_attr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(line.token_text) - attr.set_value(line.data) - state.family.add_attribute(attr) + def __family_cust_attr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(line.token_text) + attr.set_value(line.data) + state.family.add_attribute(attr) - def func_obje(self, level): - """ - n OBJE {1:1} - +1 FORM {1:1} - +1 TITL {0:1} - +1 FILE {1:1} - +1 <> {0:M} + def __obje(self, level): + """ + n OBJE {1:1} + +1 FORM {1:1} + +1 TITL {0:1} + +1 FILE {1:1} + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState() - sub_state.form = "" - sub_state.filename = "" - sub_state.title = "" - sub_state.note = "" - sub_state.level = level + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState() + sub_state.form = "" + sub_state.filename = "" + sub_state.title = "" + sub_state.note = "" + sub_state.level = level - self.parse_level(sub_state, self.object_parse_tbl, self.func_ignore) - return (sub_state.form, sub_state.filename, sub_state.title, - sub_state.note) + self.__parse_level(sub_state, self.object_parse_tbl, self.__ignore) + return (sub_state.form, sub_state.filename, sub_state.title, + sub_state.note) - def func_object_ref_form(self, line, state): - """ - +1 FORM {1:1} + def __object_ref_form(self, line, state): + """ + +1 FORM {1:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.form = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.form = line.data - def func_object_ref_titl(self, line, state): - """ - +1 TITL {0:1} + def __object_ref_titl(self, line, state): + """ + +1 TITL {0:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.title = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.title = line.data - def func_object_ref_file(self, line, state): - """ - +1 FILE {1:1} + def __object_ref_file(self, line, state): + """ + +1 FILE {1:1} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.filename = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.filename = line.data - def func_object_ref_note(self, line, state): - """ - +1 <> {0:M} + def __object_ref_note(self, line, state): + """ + +1 <> {0:M} - TODO: Fix this for full reference + TODO: Fix this for full reference - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.note = line.data + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.note = line.data - def func_family_adopt(self, line, state): - """ - n ADOP + def __family_adopt(self, line, state): + """ + n ADOP - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.frel = TYPE_ADOPT - state.mrel = TYPE_ADOPT + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.frel = TYPE_ADOPT + state.mrel = TYPE_ADOPT - def func_family_frel(self, line, state): - """ - The _FREL key is a FTW specific extension to indicate father/child - relationship. + def __family_frel(self, line, state): + """ + The _FREL key is a FTW specific extension to indicate father/child + relationship. - n _FREL + n _FREL - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.frel = PEDIGREE_TYPES.get(line.data.strip().lower()) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.frel = PEDIGREE_TYPES.get(line.data.strip().lower()) - def func_family_mrel(self, line, state): - """ - The _MREL key is a FTW specific extension to indicate father/child - relationship. + def __family_mrel(self, line, state): + """ + The _MREL key is a FTW specific extension to indicate father/child + relationship. - n _MREL + n _MREL - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.mrel = PEDIGREE_TYPES.get(line.data.strip().lower()) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.mrel = PEDIGREE_TYPES.get(line.data.strip().lower()) - def func_family_stat(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.mrel = TYPE_BIRTH - state.frel = TYPE_BIRTH + def __family_stat(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.mrel = TYPE_BIRTH + state.frel = TYPE_BIRTH - def func_event_object(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - self.not_recognized(state.level) - else: - (form, filename, title, note) = self.func_obje(state.level) - self.build_media_object(state.event, form, filename, title, note) + def __event_object(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + self.__not_recognized(state.level) + else: + (form, filename, title, note) = self.__obje(state.level) + self.build_media_object(state.event, form, filename, title, note) - def func_event_type(self, line, state): - """ + def __event_type(self, line, state): + """ Parses the TYPE line for an event. - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState """ - if state.event.get_type().is_custom(): - if GED_2_GRAMPS.has_key(line.data): - name = RelLib.EventType(GED_2_GRAMPS[line.data]) - else: - val = self.gedsource.tag2gramps(line.data) - if val: - name = RelLib.EventType((RelLib.EventType.CUSTOM, val)) - else: - name = RelLib.EventType((RelLib.EventType.CUSTOM, line[3])) - state.event.set_type(name) - else: - try: - if not GED_2_GRAMPS.has_key(line.data) and \ - not GED_2_FAMILY.has_key(line.data) and \ - line.data[0] != 'Y': - state.event.set_description(line.data) - except IndexError: - return + if state.event.get_type().is_custom(): + if GED_2_GRAMPS.has_key(line.data): + name = RelLib.EventType(GED_2_GRAMPS[line.data]) + else: + val = self.gedsource.tag2gramps(line.data) + if val: + name = RelLib.EventType((RelLib.EventType.CUSTOM, val)) + else: + name = RelLib.EventType((RelLib.EventType.CUSTOM, line[3])) + state.event.set_type(name) + else: + try: + if not GED_2_GRAMPS.has_key(line.data) and \ + not GED_2_FAMILY.has_key(line.data) and \ + line.data[0] != 'Y': + state.event.set_description(line.data) + except IndexError: + return - def func_event_date(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.event.set_date_object(line.data) + def __event_date(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.event.set_date_object(line.data) - def func_event_place(self, line, state): - """ - Parse the place portion of a event. A special case has to be made for - Family Tree Maker, which violates the GEDCOM spec. It uses the PLAC field - to store the description or value assocated with the event. + def __event_place(self, line, state): + """ + Parse the place portion of a event. A special case has to be made for + Family Tree Maker, which violates the GEDCOM spec. It uses the PLAC field + to store the description or value assocated with the event. - n PLAC {1:1} - +1 FORM {0:1} - +1 <> {0:M} - +1 <> {0:M} + n PLAC {1:1} + +1 FORM {0:1} + +1 <> {0:M} + +1 <> {0:M} - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ - if self.is_ftw and int(state.event.get_type()) in FTW_BAD_PLACE: - state.event.set_description(line.data) - else: - place = self.find_or_create_place(line.data) - place.set_title(line.data) - state.event.set_place_handle(place.handle) + if self.is_ftw and int(state.event.get_type()) in FTW_BAD_PLACE: + state.event.set_description(line.data) + else: + place = self.__find_or_create_place(line.data) + place.set_title(line.data) + state.event.set_place_handle(place.handle) - sub_state = GedcomUtils.CurrentState() - sub_state.place = place - sub_state.level = state.level+1 - sub_state.pf = self.place_parser + sub_state = GedcomUtils.CurrentState() + sub_state.place = place + sub_state.level = state.level+1 + sub_state.pf = self.place_parser - self.parse_level(sub_state, self.event_place_map, - self.func_undefined) + self.__parse_level(sub_state, self.event_place_map, + self.__undefined) - sub_state.pf.load_place(place, place.get_title()) - self.dbase.commit_place(place, self.trans) + sub_state.pf.load_place(place, place.get_title()) + self.dbase.commit_place(place, self.trans) - def func_event_place_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.place, state.level+1) + def __event_place_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.place, state.level+1) - def func_event_place_form(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.pf = GedcomUtils.PlaceParser(line) + def __event_place_form(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.pf = GedcomUtils.PlaceParser(line) - def func_event_place_object(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - self.not_recognized(state.level) - else: - (form, filename, title, note) = self.func_obje(state.level) - self.build_media_object(state.place, form, filename, title, note) + def __event_place_object(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + self.__not_recognized(state.level) + else: + (form, filename, title, note) = self.__obje(state.level) + self.build_media_object(state.place, form, filename, title, note) - def func_event_place_sour(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.place.add_source_reference(self.handle_source(line, state.level)) + def __event_place_sour(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.place.add_source_reference(self.handle_source(line, state.level)) - def func_place_map(self, line, state): - """ - - n MAP - n+1 LONG - n+1 LATI - - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState() - sub_state.level = state.level + 1 - sub_state.place = state.place - self.parse_level(sub_state, self.place_map_tbl, self.func_undefined) - state.place = sub_state.place + def __place_map(self, line, state): + """ + + n MAP + n+1 LONG + n+1 LATI + + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState() + sub_state.level = state.level + 1 + sub_state.place = state.place + self.__parse_level(sub_state, self.place_map_tbl, self.__undefined) + state.place = sub_state.place - def func_place_lati(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.place.set_latitude( line.data) + def __place_lati(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.place.set_latitude( line.data) - def func_place_long(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.place.set_longitude( line.data) + def __place_long(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.place.set_longitude( line.data) - def func_event_addr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState(level=state.level+1) - sub_state.location = RelLib.Location() - sub_state.location.set_street(line.data) - sub_state.note = [] + def __event_addr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState(level=state.level+1) + sub_state.location = RelLib.Location() + sub_state.location.set_street(line.data) + sub_state.note = [] - self.parse_level(sub_state, self.parse_loc_tbl, self.func_undefined) + self.__parse_level(sub_state, self.parse_loc_tbl, self.__undefined) - location = sub_state.location - note_list = sub_state.note + location = sub_state.location + note_list = sub_state.note - place_handle = state.event.get_place_handle() - if place_handle: - place = self.dbase.get_place_from_handle(place_handle) - index = place.get_title() + location.get_street() + place_handle = state.event.get_place_handle() + if place_handle: + place = self.dbase.get_place_from_handle(place_handle) + index = place.get_title() + location.get_street() - old_title = place.get_title() - place = self.find_or_create_place(index) - if place.get_title(): - place.set_title(old_title) - place_handle = place.handle - place.set_main_location(location) - else: - place = self.find_or_create_place(line.data) - place.set_title(line.data) - place_handle = place.handle - place.set_main_location(location) + old_title = place.get_title() + place = self.__find_or_create_place(index) + if place.get_title(): + place.set_title(old_title) + place_handle = place.handle + place.set_main_location(location) + else: + place = self.__find_or_create_place(line.data) + place.set_title(line.data) + place_handle = place.handle + place.set_main_location(location) - for note in note_list: - place.add_note(note) + for note in note_list: + place.add_note(note) - state.event.set_place_handle(place_handle) - self.dbase.commit_place(place, self.trans) + state.event.set_place_handle(place_handle) + self.dbase.commit_place(place, self.trans) - def func_event_privacy(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.event.set_privacy(True) + def __event_privacy(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.event.set_privacy(True) - def func_event_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.event, state.level+1) - - def func_event_source(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.event.add_source_reference(self.handle_source(line, state.level)) + def __event_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.event, state.level+1) + + def __event_source(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.event.add_source_reference(self.handle_source(line, state.level)) - def func_event_cause(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.CAUSE) - attr.set_value(line.data) - state.event.add_attribute(attr) + def __event_cause(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.CAUSE) + attr.set_value(line.data) + state.event.add_attribute(attr) - sub_state = GedcomUtils.CurrentState() - sub_state.event = state.event - sub_state.level = state.level + 1 + sub_state = GedcomUtils.CurrentState() + sub_state.event = state.event + sub_state.level = state.level + 1 - self.parse_level(sub_state, self.event_cause_tbl, self.func_undefined) + self.__parse_level(sub_state, self.event_cause_tbl, self.__undefined) - def func_event_cause_source(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.event.add_source_reference(self.handle_source(line, - state.level+1)) + def __event_cause_source(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.event.add_source_reference(self.handle_source(line, + state.level+1)) - def func_event_age(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.AGE) - attr.set_value(line.data) - state.event_ref.add_attribute(attr) + def __event_age(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.AGE) + attr.set_value(line.data) + state.event_ref.add_attribute(attr) - def func_event_husb(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - while True: - line = self.get_next() - if self.level_is_finished(line, state.level): - break - elif line.token == TOKEN_AGE: - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.FATHER_AGE) - attr.set_value(line.data) - state.event_ref.add_attribute(attr) + def __event_husb(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, state.level): + break + elif line.token == TOKEN_AGE: + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.FATHER_AGE) + attr.set_value(line.data) + state.event_ref.add_attribute(attr) - def func_event_wife(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - while True: - line = self.get_next() - if self.level_is_finished(line, state.level): - break - elif line.token == TOKEN_AGE: - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.MOTHER_AGE) - attr.set_value(line.data) - state.event_ref.add_attribute(attr) + def __event_wife(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, state.level): + break + elif line.token == TOKEN_AGE: + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.MOTHER_AGE) + attr.set_value(line.data) + state.event_ref.add_attribute(attr) - def func_event_agnc(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.AGENCY) - attr.set_value(line.data) - state.event.add_attribute(attr) + def __event_agnc(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.AGENCY) + attr.set_value(line.data) + state.event.add_attribute(attr) - def func_event_witness(self,line,state): - """ - Parse the witness of an event + def __event_witness(self, line, state): + """ + Parse the witness of an event - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == "@": - """ - n _WITN @@ - +1 TYPE - """ - assert( state.event.handle) # event handle is required to be set - wit = self.find_or_create_person(self.pid_map[line.data]) - self.added.add(wit.handle) - event_ref = RelLib.EventRef() - event_ref.set_reference_handle(state.event.handle) - while True: - line = self.get_next() - if self.level_is_finished(line, state.level+1): - break - elif line.token == TOKEN_TYPE: - if line.data in ("WITNESS_OF_MARRIAGE"): - r = RelLib.EventRoleType(RelLib.EventRoleType.WITNESS) - else: - r = RelLib.EventRoleType((RelLib.EventRoleType.CUSTOM, line.data)) - event_ref.set_role(r) - wit.add_event_ref(event_ref) - self.dbase.commit_person(wit, self.trans) - else: - """ - n _WITN - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.WITNESS) - attr.set_value(line.data) - state.event.add_attribute(attr) - - def func_person_adopt_famc(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - gid = self.fid_map[line.data] - handle = self.find_family_handle(gid) - family = self.find_or_create_family(gid) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == "@": + """ + n _WITN @@ + +1 TYPE + """ + assert( state.event.handle) # event handle is required to be set + wit = self.__find_or_create_person(self.pid_map[line.data]) + self.added.add(wit.handle) + event_ref = RelLib.EventRef() + event_ref.set_reference_handle(state.event.handle) + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, state.level+1): + break + elif line.token == TOKEN_TYPE: + if line.data in ("WITNESS_OF_MARRIAGE"): + r = RelLib.EventRoleType(RelLib.EventRoleType.WITNESS) + else: + r = RelLib.EventRoleType((RelLib.EventRoleType.CUSTOM, + line.data)) + event_ref.set_role(r) + wit.add_event_ref(event_ref) + self.dbase.commit_person(wit, self.trans) + else: + """ + n _WITN + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.WITNESS) + attr.set_value(line.data) + state.event.add_attribute(attr) + + def __person_adopt_famc(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + gid = self.fid_map[line.data] + handle = self.__find_family_handle(gid) + family = self.__find_or_create_family(gid) - sub_state = GedcomUtils.CurrentState(level=state.level+1) - sub_state.mrel = TYPE_BIRTH - sub_state.frel = TYPE_BIRTH + sub_state = GedcomUtils.CurrentState(level=state.level+1) + sub_state.mrel = TYPE_BIRTH + sub_state.frel = TYPE_BIRTH - self.parse_level(sub_state, self.parse_person_adopt, - self.func_undefined) + self.__parse_level(sub_state, self.parse_person_adopt, + self.__undefined) - if (int(sub_state.mrel) == RelLib.ChildRefType.BIRTH and - int(sub_state.frel) == RelLib.ChildRefType.BIRTH): - sub_state.mrel = sub_state.frel = TYPE_ADOPT + if (int(sub_state.mrel) == RelLib.ChildRefType.BIRTH and + int(sub_state.frel) == RelLib.ChildRefType.BIRTH): + sub_state.mrel = sub_state.frel = TYPE_ADOPT - if state.person.get_main_parents_family_handle() == handle: - state.person.set_main_parent_family_handle(None) - state.person.add_parent_family_handle(handle) - - reflist = [ ref for ref in family.get_child_ref_list() \ - if ref.ref == state.person.handle ] - if reflist: - ref = reflist[0] - ref.set_father_relation(sub_state.frel) - ref.set_mother_relation(sub_state.mrel) - else: - ref = RelLib.ChildRef() - ref.ref = state.person.handle - ref.set_father_relation(sub_state.frel) - ref.set_mother_relation(sub_state.mrel) - family.add_child_ref(ref) - self.dbase.commit_family(family, self.trans) + if state.person.get_main_parents_family_handle() == handle: + state.person.set_main_parent_family_handle(None) + state.person.add_parent_family_handle(handle) + + reflist = [ ref for ref in family.get_child_ref_list() \ + if ref.ref == state.person.handle ] + if reflist: + ref = reflist[0] + ref.set_father_relation(sub_state.frel) + ref.set_mother_relation(sub_state.mrel) + else: + ref = RelLib.ChildRef() + ref.ref = state.person.handle + ref.set_father_relation(sub_state.frel) + ref.set_mother_relation(sub_state.mrel) + family.add_child_ref(ref) + self.dbase.commit_family(family, self.trans) - def func_person_adopt_famc_adopt(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data.strip() == "HUSB": - state.frel = TYPE_ADOPT - elif line.data.strip() == "WIFE": - state.mrel = TYPE_ADOPT - else: - state.mrel = TYPE_ADOPT - state.frel = TYPE_ADOPT + def __person_adopt_famc_adopt(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data.strip() == "HUSB": + state.frel = TYPE_ADOPT + elif line.data.strip() == "WIFE": + state.mrel = TYPE_ADOPT + else: + state.mrel = TYPE_ADOPT + state.frel = TYPE_ADOPT - def func_person_birth_famc(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - handle = self.find_family_handle(self.fid_map[line.data]) + def __person_birth_famc(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + handle = self.__find_family_handle(self.fid_map[line.data]) - if state.person.get_main_parents_family_handle() == handle: - state.person.set_main_parent_family_handle(None) - state.person.add_parent_family_handle(handle) - - frel = mrel = RelLib.ChildRefType.BIRTH + if state.person.get_main_parents_family_handle() == handle: + state.person.set_main_parent_family_handle(None) + state.person.add_parent_family_handle(handle) + + frel = mrel = RelLib.ChildRefType.BIRTH - family = self.dbase.find_family_from_handle(handle, self.trans) - reflist = [ ref for ref in family.get_child_ref_list() \ - if ref.ref == state.person.handle ] - if reflist: - ref = reflist[0] - ref.set_father_relation(frel) - ref.set_mother_relation(mrel) - else: - ref = RelLib.ChildRef() - ref.ref = state.person.handle - ref.set_father_relation(frel) - ref.set_mother_relation(mrel) - family.add_child_ref(ref) - self.dbase.commit_family(family, self.trans) + family = self.dbase.find_family_from_handle(handle, self.trans) + reflist = [ ref for ref in family.get_child_ref_list() \ + if ref.ref == state.person.handle ] + if reflist: + ref = reflist[0] + ref.set_father_relation(frel) + ref.set_mother_relation(mrel) + else: + ref = RelLib.ChildRef() + ref.ref = state.person.handle + ref.set_father_relation(frel) + ref.set_mother_relation(mrel) + family.add_child_ref(ref) + self.dbase.commit_family(family, self.trans) - def func_address_date(self, line, state): - """ - Parses the DATE line of an ADDR tag + def __address_date(self, line, state): + """ + Parses the DATE line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_date_object(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_date_object(line.data) - def func_address_city(self, line, state): - """ - Parses the CITY line of an ADDR tag + def __address_city(self, line, state): + """ + Parses the CITY line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_city(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_city(line.data) - def func_address_state(self, line, state): - """ - Parses the STAE line of an ADDR tag + def __address_state(self, line, state): + """ + Parses the STAE line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_state(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_state(line.data) - def func_address_post(self, line, state): - """ - Parses the POST line of an ADDR tag + def __address_post(self, line, state): + """ + Parses the POST line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_postal_code(line.data) - - def func_address_country(self, line, state): - """ - Parses the country line of an ADDR tag + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_postal_code(line.data) + + def __address_country(self, line, state): + """ + Parses the country line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_country(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_country(line.data) - def func_address_phone(self, line, state): - """ - Parses the PHON line of an ADDR tag + def __address_phone(self, line, state): + """ + Parses the PHON line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.set_phone(line.data) - - def func_address_sour(self, line, state): - """ - Parses the SOUR line of an ADDR tag + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.set_phone(line.data) + + def __address_sour(self, line, state): + """ + Parses the SOUR line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.addr.add_source_reference(self.handle_source(line, state.level+1)) - - def func_address_note(self, line, state): - """ - Parses the NOTE line of an ADDR tag + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.addr.add_source_reference(self.handle_source(line, state.level+1)) + + def __address_note(self, line, state): + """ + Parses the NOTE line of an ADDR tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.addr, state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.addr, state.level+1) - def func_srcref_page(self, line, state): - """ - Parses the PAGE line of an SOUR instance tag + def __srcref_page(self, line, state): + """ + Parses the PAGE line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.src_ref.set_page(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.src_ref.set_page(line.data) - def func_srcref_date(self, line, state): - """ - Parses the DATE line of an SOUR instance tag + def __srcref_date(self, line, state): + """ + Parses the DATE line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.src_ref.set_date_object(line.data) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.src_ref.set_date_object(line.data) - def func_srcref_data(self, line, state): - """ - Parses the DATA line of an SOUR instance tag + def __srcref_data(self, line, state): + """ + Parses the DATA line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState(level=state.level+1) - sub_state.src_ref = state.src_ref + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState(level=state.level+1) + sub_state.src_ref = state.src_ref - self.parse_level(sub_state, self.srcref_data_tbl, self.func_undefined) + self.__parse_level(sub_state, self.srcref_data_tbl, self.__undefined) - def func_source_data_date(self, line, state): - state.src_ref.set_date_object(line.data) + def __source_data_date(self, line, state): + state.src_ref.set_date_object(line.data) - def func_source_data_text(self, line, state): - state.src_ref.set_text(line.data) + def __source_data_text(self, line, state): + state.src_ref.set_text(line.data) - def func_source_data_note(self, line, state): - self.parse_note(line, state.src_ref, state.level) + def __source_data_note(self, line, state): + self.__parse_note(line, state.src_ref, state.level) - def func_srcref_obje(self, line, state): - """ - Parses the OBJE line of an SOUR instance tag + def __srcref_obje(self, line, state): + """ + Parses the OBJE line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - self.not_recognized(state.level) - else: - src = self.dbase.get_source_from_handle(state.handle) - (form, filename, title, note) = self.func_obje(state.level) - self.build_media_object(src, form, filename, title, note) - self.dbase.commit_source(src, self.trans) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + self.__not_recognized(state.level) + else: + src = self.dbase.get_source_from_handle(state.handle) + (form, filename, title, note) = self.__obje(state.level) + self.build_media_object(src, form, filename, title, note) + self.dbase.commit_source(src, self.trans) - def func_srcref_refn(self, line, state): - """ - Parses the REFN line of an SOUR instance tag + def __srcref_refn(self, line, state): + """ + Parses the REFN line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_srcref_quay(self, line, state): - """ - Parses the QUAY line of an SOUR instance tag + def __srcref_quay(self, line, state): + """ + Parses the QUAY line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - try: - val = int(line.data) - except ValueError: - return - # If value is greater than 3, cap at 3 - val = min(val, 3) - if val > 1: - state.src_ref.set_confidence_level(val+1) - else: - state.src_ref.set_confidence_level(val) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + try: + val = int(line.data) + except ValueError: + return + # If value is greater than 3, cap at 3 + val = min(val, 3) + if val > 1: + state.src_ref.set_confidence_level(val+1) + else: + state.src_ref.set_confidence_level(val) - def func_srcref_note(self, line, state): - """ - Parses the NOTE line of an SOUR instance tag + def __srcref_note(self, line, state): + """ + Parses the NOTE line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.src_ref, state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.src_ref, state.level+1) - def func_srcref_text(self, line, state): - """ - Parses the TEXT line of an SOUR instance tag + def __srcref_text(self, line, state): + """ + Parses the TEXT line of an SOUR instance tag - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.src_ref.set_text(line.data) - self.skip_subordinate_levels(state.level+1) + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.src_ref.set_text(line.data) + self.__skip_subordinate_levels(state.level+1) - def parse_source(self, name, level): - """ - n @@ SOUR {1:1} - +1 DATA {0:1} - +2 EVEN {0:M} - +3 DATE {0:1} - +3 PLAC {0:1} - +2 AGNC {0:1} - +2 <> {0:M} - +1 AUTH {0:1} - +1 TITL {0:1} - +1 ABBR {0:1} - +1 PUBL {0:1} - +1 TEXT {0:1} - +1 <> {0:1} - +1 <> {0:M} - +1 <> {0:M} - +1 REFN {0:M} - +2 TYPE {0:1} - +1 RIN {0:1} - +1 <> {0:1} - """ + def __parse_source(self, name, level): + """ + n @@ SOUR {1:1} + +1 DATA {0:1} + +2 EVEN {0:M} + +3 DATE {0:1} + +3 PLAC {0:1} + +2 AGNC {0:1} + +2 <> {0:M} + +1 AUTH {0:1} + +1 TITL {0:1} + +1 ABBR {0:1} + +1 PUBL {0:1} + +1 TEXT {0:1} + +1 <> {0:1} + +1 <> {0:M} + +1 <> {0:M} + +1 REFN {0:M} + +2 TYPE {0:1} + +1 RIN {0:1} + +1 <> {0:1} + """ - state = GedcomUtils.CurrentState() - state.source = self.find_or_create_source(self.sid_map[name]) - state.source.set_title("No title - ID %s" % - state.source.get_gramps_id()) - state.level = level + state = GedcomUtils.CurrentState() + state.source = self.__find_or_create_source(self.sid_map[name]) + state.source.set_title("No title - ID %s" % + state.source.get_gramps_id()) + state.level = level - self.parse_level(state, self.source_func, self.func_undefined) - self.dbase.commit_source(state.source, self.trans) + self.__parse_level(state, self.source_func, self.__undefined) + self.dbase.commit_source(state.source, self.trans) - def func_source_attr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.set_data_item(line.token_text, line.data) + def __source_attr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.set_data_item(line.token_text, line.data) - def func_source_object(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - self.not_recognized(state.level) - else: - (form, filename, title, note) = self.func_obje(state.level+1) - self.build_media_object(state.source, form, filename, title, note) + def __source_object(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + self.__not_recognized(state.level) + else: + (form, filename, title, note) = self.__obje(state.level+1) + self.build_media_object(state.source, form, filename, title, note) - def func_source_chan(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_change(line, state.source, state.level+1) + def __source_chan(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_change(line, state.source, state.level+1) - def func_source_undef(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.not_recognized(state.level+1) + def __source_undef(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__not_recognized(state.level+1) - def func_source_repo(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if line.data and line.data[0] == '@': - gid = self.rid_map[line.data] - repo = self.find_or_create_repository(gid) - else: - gid = self.repo2id.get(line.data) - repo = self.find_or_create_repository(gid) - self.repo2id[line.data] = repo.get_gramps_id() - repo.set_name(line.data) - self.dbase.commit_repository(repo, self.trans) - repo_ref = RelLib.RepoRef() - repo_ref.set_reference_handle(repo.handle) + def __source_repo(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if line.data and line.data[0] == '@': + gid = self.rid_map[line.data] + repo = self.__find_or_create_repository(gid) + else: + gid = self.repo2id.get(line.data) + repo = self.__find_or_create_repository(gid) + self.repo2id[line.data] = repo.get_gramps_id() + repo.set_name(line.data) + self.dbase.commit_repository(repo, self.trans) + repo_ref = RelLib.RepoRef() + repo_ref.set_reference_handle(repo.handle) - sub_state = GedcomUtils.CurrentState() - sub_state.repo_ref = repo_ref - sub_state.level = state.level + 1 + sub_state = GedcomUtils.CurrentState() + sub_state.repo_ref = repo_ref + sub_state.level = state.level + 1 - self.parse_level(sub_state, self.repo_ref_tbl, self.func_undefined) + self.__parse_level(sub_state, self.repo_ref_tbl, self.__undefined) - state.source.add_repo_reference(repo_ref) + state.source.add_repo_reference(repo_ref) - def func_repo_ref_call(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.repo_ref.set_call_number(line.data) - self.skip_subordinate_levels(state.level+1) + def __repo_ref_call(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.repo_ref.set_call_number(line.data) + self.__skip_subordinate_levels(state.level+1) - def func_repo_ref_medi(self, line, state): - name = line.data - mtype = MEDIA_MAP.get(name.lower(), (RelLib.SourceMediaType.CUSTOM, name)) - state.repo_ref.set_media_type(mtype) + def __repo_ref_medi(self, line, state): + name = line.data + mtype = MEDIA_MAP.get(name.lower(), (RelLib.SourceMediaType.CUSTOM, name)) + state.repo_ref.set_media_type(mtype) - def func_repo_ref_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.repo_ref, state.level+1) + def __repo_ref_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.repo_ref, state.level+1) - def func_source_abbr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.set_abbreviation(line.data) + def __source_abbr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.set_abbreviation(line.data) - def func_source_agnc(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - attr = RelLib.Attribute() - attr.set_type(RelLib.AttributeType.AGENCY) - attr.set_value(line.data) - state.source.add_attribute(attr) + def __source_agnc(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + attr = RelLib.Attribute() + attr.set_type(RelLib.AttributeType.AGENCY) + attr.set_value(line.data) + state.source.add_attribute(attr) - def func_source_text(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.add_note(line.data) + def __source_text(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.add_note(line.data) - def func_source_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.source, state.level+1) + def __source_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.source, state.level+1) - def func_source_auth(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.set_author(line.data) + def __source_auth(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.set_author(line.data) - def func_source_publ(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.set_publication_info(line.data) - self.skip_subordinate_levels(state.level+1) + def __source_publ(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.set_publication_info(line.data) + self.__skip_subordinate_levels(state.level+1) - def func_source_title(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.source.set_title(line.data.replace('\n',' ')) + def __source_title(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.source.set_title(line.data.replace('\n',' ')) - def func_source_taxt_peri(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.source.get_title() == "": - state.source.set_title(line.data.replace('\n',' ')) + def __source_taxt_peri(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.source.get_title() == "": + state.source.set_title(line.data.replace('\n',' ')) - def parse_obje(self, line): - """ - n @XREF:OBJE@ OBJE {1:1} - +1 FORM {1:1} p.* - +1 TITL {0:1} p.* - +1 <> {0:M} p.* - +1 BLOB {1:1} - +2 CONT {1:M} p.* - +1 OBJE @@ /* chain to continued object */ {0:1} p.* - +1 REFN {0:M} p.* - +2 TYPE {0:1} p.* - +1 RIN {0:1} p.* - +1 <> {0:1} p.* - """ - gid = line.token_text.strip() - media = self.find_or_create_object(self.oid_map[gid]) + def __parse_obje(self, line): + """ + n @XREF:OBJE@ OBJE {1:1} + +1 FORM {1:1} p.* + +1 TITL {0:1} p.* + +1 <> {0:M} p.* + +1 BLOB {1:1} + +2 CONT {1:M} p.* + +1 OBJE @@ /* chain to continued object */ {0:1} p.* + +1 REFN {0:M} p.* + +2 TYPE {0:1} p.* + +1 RIN {0:1} p.* + +1 <> {0:1} p.* + """ + gid = line.token_text.strip() + media = self.__find_or_create_object(self.oid_map[gid]) - state = GedcomUtils.CurrentState() - state.media = media - state.level = 1 + state = GedcomUtils.CurrentState() + state.media = media + state.level = 1 - self.parse_level(state, self.obje_func, self.func_undefined) + self.__parse_level(state, self.obje_func, self.__undefined) - # Add the default reference if no source has found - self.add_default_source(media) + # Add the default reference if no source has found + self.add_default_source(media) - # commit the person to the database - if media.change: - self.dbase.commit_media_object(media, self.trans, - change_time=media.change) - else: - self.dbase.commit_media_object(media, self.trans) + # commit the person to the database + if media.change: + self.dbase.commit_media_object(media, self.trans, + change_time=media.change) + else: + self.dbase.commit_media_object(media, self.trans) - def func_obje_form(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - # TODO: FIX THIS!!! - state.media_form = line.data.strip() - self.skip_subordinate_levels(state.level+1) + def __obje_form(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + # TODO: FIX THIS!!! + state.media_form = line.data.strip() + self.__skip_subordinate_levels(state.level+1) - def func_obje_file(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - (file_ok, filename) = self.find_file(line.data, self.dir_path) - if state.media != "URL": - if not file_ok: - self.warn(_("Could not import %s") % filename[0]) - path = filename[0].replace('\\', os.path.sep) - state.media.set_path(path) - state.media.set_mime_type(Mime.get_type(path)) - if not state.media.get_description(): - state.media.set_description(path) + def __obje_file(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + (file_ok, filename) = self.__find_file(line.data, self.dir_path) + if state.media != "URL": + if not file_ok: + self.warn(_("Could not import %s") % filename[0]) + path = filename[0].replace('\\', os.path.sep) + state.media.set_path(path) + state.media.set_mime_type(Mime.get_type(path)) + if not state.media.get_description(): + state.media.set_description(path) - def func_obje_title(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.media.set_description(line.data) + def __obje_title(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.media.set_description(line.data) - def func_obje_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.media, state.level+1) + def __obje_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.media, state.level+1) - def func_obje_blob(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + def __obje_blob(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_obje_refn(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + def __obje_refn(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_obje_type(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + def __obje_type(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_obje_rin(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + def __obje_rin(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_obje_chan(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.skip_subordinate_levels(state.level+1) + def __obje_chan(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__skip_subordinate_levels(state.level+1) - def func_person_attr_type(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.attr.get_type() == "": - if GED_2_GRAMPS.has_key(line.data): - name = GED_2_GRAMPS[line.data] - else: - val = self.gedsource.tag2gramps(line.data) - if val: - name = val - else: - name = line.data - state.attr.set_type(name) + def __person_attr_type(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.attr.get_type() == "": + if GED_2_GRAMPS.has_key(line.data): + name = GED_2_GRAMPS[line.data] + else: + val = self.gedsource.tag2gramps(line.data) + if val: + name = val + else: + name = line.data + state.attr.set_type(name) - def func_person_attr_source(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.attr.add_source_reference(self.handle_source(line, state.level)) + def __person_attr_source(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.attr.add_source_reference(self.handle_source(line, state.level)) - def func_person_attr_place(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - val = line.data - if state.attr.get_value() == "": - state.attr.set_value(val) - self.skip_subordinate_levels(state.level) + def __person_attr_place(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + val = line.data + if state.attr.get_value() == "": + state.attr.set_value(val) + self.__skip_subordinate_levels(state.level) - def func_person_attr_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.attr, state.level+1) + def __person_attr_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.attr, state.level+1) #---------------------------------------------------------------------- # # REPO parsing # #---------------------------------------------------------------------- - def parse_repo(self, line): - """ - REPOSITORY_RECORD:= - n @@ REPO {1:1} - +1 NAME {0:1} p.* - +1 <> {0:1} p.* - +1 <> {0:M} p.* - +1 REFN {0:M} p.* - +1 RIN {0:1} p.* - +1 <> {0:1} p. - """ - repo = self.find_or_create_repository(line.token_text) - self.added.add(repo.handle) + def __parse_repo(self, line): + """ + REPOSITORY_RECORD:= + n @@ REPO {1:1} + +1 NAME {0:1} p.* + +1 <> {0:1} p.* + +1 <> {0:M} p.* + +1 REFN {0:M} p.* + +1 RIN {0:1} p.* + +1 <> {0:1} p. + """ + repo = self.__find_or_create_repository(line.token_text) + self.added.add(repo.handle) - state = GedcomUtils.CurrentState() - state.repo = repo - state.level = 1 - self.parse_level(state, self.repo_parse_tbl, self.func_ignore) + state = GedcomUtils.CurrentState() + state.repo = repo + state.level = 1 + self.__parse_level(state, self.repo_parse_tbl, self.__ignore) - self.dbase.commit_repository(repo, self.trans) + self.dbase.commit_repository(repo, self.trans) - def func_repo_name(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - state.repo.set_name(line.data) + def __repo_name(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + state.repo.set_name(line.data) - def func_repo_addr(self, line, state): - """ - n ADDR {0:1} - +1 CONT {0:M} - +1 ADR1 {0:1} - +1 ADR2 {0:1} - +1 CITY {0:1} - +1 STAE {0:1} - +1 POST {0:1} - +1 CTRY {0:1} - n PHON {0:3} + def __repo_addr(self, line, state): + """ + n ADDR {0:1} + +1 CONT {0:M} + +1 ADR1 {0:1} + +1 ADR2 {0:1} + +1 CITY {0:1} + +1 STAE {0:1} + +1 POST {0:1} + +1 CTRY {0:1} + n PHON {0:3} - Some repositories do not try to break up the address, - instead they put everything on a single line. Try to determine - if this happened, and try to fix it. - """ + Some repositories do not try to break up the address, + instead they put everything on a single line. Try to determine + if this happened, and try to fix it. + """ - addr = RelLib.Address() - addr.set_street(line.data) + addr = RelLib.Address() + addr.set_street(line.data) - sub_state = GedcomUtils.CurrentState() - sub_state.level = state.level+1 - sub_state.addr = addr + sub_state = GedcomUtils.CurrentState() + sub_state.level = state.level+1 + sub_state.addr = addr - self.parse_level(sub_state, self.parse_addr_tbl, self.func_ignore) + self.__parse_level(sub_state, self.parse_addr_tbl, self.__ignore) - text = addr.get_street() - if not addr.get_city() and not addr.get_state() and \ - not addr.get_postal_code() and not addr.get_country(): - - match = ADDR_RE.match(text) - if match: - groups = match.groups() - addr.set_street(groups[0].strip()) - addr.set_city(groups[2].strip()) - addr.set_state(groups[3].strip()) - addr.set_postal_code(groups[4].strip()) - addr.set_country(groups[5].strip()) - - match = ADDR2_RE.match(text) - if match: - groups = match.groups() - addr.set_street(groups[0].strip()) - addr.set_city(groups[2].strip()) - addr.set_state(groups[3].strip()) - addr.set_postal_code(groups[4].strip()) + text = addr.get_street() + if not addr.get_city() and not addr.get_state() and \ + not addr.get_postal_code() and not addr.get_country(): + + match = ADDR_RE.match(text) + if match: + groups = match.groups() + addr.set_street(groups[0].strip()) + addr.set_city(groups[2].strip()) + addr.set_state(groups[3].strip()) + addr.set_postal_code(groups[4].strip()) + addr.set_country(groups[5].strip()) + + match = ADDR2_RE.match(text) + if match: + groups = match.groups() + addr.set_street(groups[0].strip()) + addr.set_city(groups[2].strip()) + addr.set_state(groups[3].strip()) + addr.set_postal_code(groups[4].strip()) - match = ADDR3_RE.match(text) - if match: - groups = match.groups() - addr.set_street(groups[0].strip()) - addr.set_city(groups[2].strip()) - addr.set_state(groups[3].strip()) + match = ADDR3_RE.match(text) + if match: + groups = match.groups() + addr.set_street(groups[0].strip()) + addr.set_city(groups[2].strip()) + addr.set_state(groups[3].strip()) - state.repo.add_address(addr) + state.repo.add_address(addr) - def func_location_addr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - val = state.location.get_street() - if val: - val = "%s, %s" % (val, line.data.strip()) - else: - val = line.data.strip() - state.location.set_street(val.replace('\n',' ')) + def __location_addr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + val = state.location.get_street() + if val: + val = "%s, %s" % (val, line.data.strip()) + else: + val = line.data.strip() + state.location.set_street(val.replace('\n',' ')) - def func_location_date(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - state.location.set_date_object(line.data) + def __location_date(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + state.location.set_date_object(line.data) - def func_location_city(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - state.location.set_city(line.data) + def __location_city(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + state.location.set_city(line.data) - def func_location_stae(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - state.location.set_state(line.data) + def __location_stae(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + state.location.set_state(line.data) - def func_location_post(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - state.location.set_postal_code(line.data) + def __location_post(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + state.location.set_postal_code(line.data) - def func_location_ctry(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - state.location.set_country(line.data) + def __location_ctry(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + state.location.set_country(line.data) - def func_location_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if not state.location: - state.location = RelLib.Location() - self.parse_note(line, state.event, state.level+1) + def __location_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if not state.location: + state.location = RelLib.Location() + self.__parse_note(line, state.event, state.level+1) def map_ancestry_com(self, original_gid): """ @@ -4071,248 +4071,248 @@ class GedcomParser(UpdateCallback): We have to make sure we use the original person ID, since the StageOne parser does not remap colliding IDs. """ - for fams_id in self.fams_map.get(original_gid,[]): + for fams_id in self.fams_map.get(original_gid, []): mapped_id = self.fid_map[fams_id] - fams_handle = self.find_family_handle(mapped_id) + fams_handle = self.__find_family_handle(mapped_id) self.person.add_family_handle(fams_handle) - for famc_id in self.famc_map.get(original_gid,[]): + for famc_id in self.famc_map.get(original_gid, []): mapped_id = self.fid_map[famc_id] - famc_handle = self.find_family_handle(mapped_id) + famc_handle = self.__find_family_handle(mapped_id) self.person.add_parent_family_handle(famc_handle) - def func_optional_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_note(line, state.obj, state.level) + def __optional_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_note(line, state.obj, state.level) - def parse_header_source(self): - state = GedcomUtils.CurrentState(level=1) - self.parse_level(state, self.header_sour, self.func_undefined) + def __parse_header_source(self): + state = GedcomUtils.CurrentState(level=1) + self.__parse_level(state, self.header_sour, self.__undefined) - def func_header_sour(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.gedsource = self.gedmap.get_from_source_tag(line.data) - self.lexer.set_broken_conc(self.gedsource.get_conc()) - if line.data == "FTW": - self.is_ftw = True - elif line.data == "Ancestry.com Family Trees": - self.is_ancestry_com = True - state.genby = line.data + def __header_sour(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.gedsource = self.gedmap.get_from_source_tag(line.data) + self.lexer.set_broken_conc(self.gedsource.get_conc()) + if line.data == "FTW": + self.is_ftw = True + elif line.data == "Ancestry.com Family Trees": + self.is_ancestry_com = True + state.genby = line.data - def func_header_vers(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - self.def_src.set_data_item('Generated by',"%s %s" % - (state.genby, line.data)) - - def func_header_file(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - filename = os.path.basename(line.data).split('\\')[-1] - self.def_src.set_title(_("Import from %s") % filename) + def __header_vers(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + self.def_src.set_data_item('Generated by',"%s %s" % + (state.genby, line.data)) + + def __header_file(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + filename = os.path.basename(line.data).split('\\')[-1] + self.def_src.set_title(_("Import from %s") % filename) - def func_header_copr(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - self.def_src.set_publication_info(line.data) + def __header_copr(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + self.def_src.set_publication_info(line.data) - def func_header_subm(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - sub_state = GedcomUtils.CurrentState(level=state.level+1) - self.parse_level(sub_state, self.header_subm, self.func_ignore) + def __header_subm(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + sub_state = GedcomUtils.CurrentState(level=state.level+1) + self.__parse_level(sub_state, self.header_subm, self.__ignore) - def func_header_dest(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if state.genby == "GRAMPS": - self.gedsource = self.gedmap.get_from_source_tag(line.data) - self.lexer.set_broken_conc(self.gedsource.get_conc()) + def __header_dest(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if state.genby == "GRAMPS": + self.gedsource = self.gedmap.get_from_source_tag(line.data) + self.lexer.set_broken_conc(self.gedsource.get_conc()) - def func_header_plac(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - self.parse_place_form(2) + def __header_plac(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + self.__parse_place_form(2) - def func_header_date(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - self.def_src.set_data_item('Creation date', line.data) + def __header_date(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + self.def_src.set_data_item('Creation date', line.data) - def func_header_note(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - self.parse_note(line, self.def_src, 2, '') + def __header_note(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + self.__parse_note(line, self.def_src, 2, '') - def func_header_subm_name(self, line, state): - """ - @param line: The current line in GedLine format - @type line: GedLine - @param state: The current state - @type state: CurrentState - """ - if self.use_def_src: - self.def_src.set_author(line.data) + def __header_subm_name(self, line, state): + """ + @param line: The current line in GedLine format + @type line: GedLine + @param state: The current state + @type state: CurrentState + """ + if self.use_def_src: + self.def_src.set_author(line.data) ############################################################################### - def parse_note(self, line, obj, level): - # reference to a named note defined elsewhere - if line.token == TOKEN_RNOTE: - obj.add_note(self.nid_map[line.data.strip()]) - else: - new_note = RelLib.Note(line.data) - new_note.set_gramps_id(self.dbase.find_next_note_gramps_id()) - new_note.set_handle(Utils.create_id()) - self.dbase.commit_note(new_note,self.trans) - obj.add_note(new_note.handle) - self.skip_subordinate_levels(level+1) + def __parse_note(self, line, obj, level): + # reference to a named note defined elsewhere + if line.token == TOKEN_RNOTE: + obj.add_note(self.nid_map[line.data.strip()]) + else: + new_note = RelLib.Note(line.data) + new_note.set_gramps_id(self.dbase.find_next_note_gramps_id()) + new_note.set_handle(Utils.create_id()) + self.dbase.commit_note(new_note,self.trans) + obj.add_note(new_note.handle) + self.__skip_subordinate_levels(level+1) - def parse_source_reference(self, src_ref, level, handle): - """Reads the data associated with a SOUR reference""" - state = GedcomUtils.CurrentState() - state.level = level+1 - state.src_ref = src_ref - state.handle = handle - self.parse_level(state, self.srcref_parse_tbl, self.func_ignore) + def __parse_source_reference(self, src_ref, level, handle): + """Reads the data associated with a SOUR reference""" + state = GedcomUtils.CurrentState() + state.level = level+1 + state.src_ref = src_ref + state.handle = handle + self.__parse_level(state, self.srcref_parse_tbl, self.__ignore) - def parse_header_head(self): - """validiates that this is a valid GEDCOM file""" - line = self.get_next() - if line.token != TOKEN_HEAD: - raise Errors.GedcomError("%s is not a GEDCOM file" % self.filename) + def __parse_header_head(self): + """validiates that this is a valid GEDCOM file""" + line = self.__get_next_line() + if line.token != TOKEN_HEAD: + raise Errors.GedcomError("%s is not a GEDCOM file" % self.filename) - def skip_subordinate_levels(self, level): - while True: - line = self.get_next() - if self.level_is_finished(line, level): - return + def __skip_subordinate_levels(self, level): + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, level): + return def ignore_change_data(self, level): - line = self.get_next() - if line.token == TOKEN_CHAN: - self.skip_subordinate_levels(level+1) - else: - self.backup() + line = self.__get_next_line() + if line.token == TOKEN_CHAN: + self.__skip_subordinate_levels(level+1) + else: + self._backup() - def parse_place_form(self, level): - while True: - line = self.get_next() + def __parse_place_form(self, level): + while True: + line = self.__get_next_line() - if self.level_is_finished(line, level): - break - elif line.token == TOKEN_FORM: - self.place_parser.parse_form(line) - else: - self.not_recognized(level+1) + if self.__level_is_finished(line, level): + break + elif line.token == TOKEN_FORM: + self.place_parser.parse_form(line) + else: + self.__not_recognized(level+1) - def parse_date(self, level): - while True: - line = self.get_next() - if self.level_is_finished(line, level): - break - elif line.token == TOKEN_TIME: - pass - else: - self.not_recognized(level+1) + def __parse_date(self, level): + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, level): + break + elif line.token == TOKEN_TIME: + pass + else: + self.__not_recognized(level+1) def handle_source(self, line, level): - source_ref = RelLib.SourceRef() - if line.data and line.data[0] != "@": - title = line.data - handle = self.inline_srcs.get(title, Utils.create_id()) - src = RelLib.Source() - src.handle = handle - src.gramps_id = self.dbase.find_next_source_gramps_id() - self.inline_srcs[title] = handle - else: - src = self.find_or_create_source(self.sid_map[line.data]) - self.dbase.commit_source(src, self.trans) - self.parse_source_reference(source_ref, level, src.handle) - source_ref.set_reference_handle(src.handle) - return source_ref + source_ref = RelLib.SourceRef() + if line.data and line.data[0] != "@": + title = line.data + handle = self.inline_srcs.get(title, Utils.create_id()) + src = RelLib.Source() + src.handle = handle + src.gramps_id = self.dbase.find_next_source_gramps_id() + self.inline_srcs[title] = handle + else: + src = self.__find_or_create_source(self.sid_map[line.data]) + self.dbase.commit_source(src, self.trans) + self.__parse_source_reference(source_ref, level, src.handle) + source_ref.set_reference_handle(src.handle) + return source_ref def resolve_refns(self): - return + return - prefix = self.dbase.iprefix - index = 0 - new_pmax = self.dbase.pmap_index - for pid in self.added: - index += 1 - if self.refn.has_key(pid): - val = self.refn[pid] - new_key = prefix % val - new_pmax = max(new_pmax, val) + prefix = self.dbase.iprefix + index = 0 + new_pmax = self.dbase.pmap_index + for pid in self.added: + index += 1 + if self.refn.has_key(pid): + val = self.refn[pid] + new_key = prefix % val + new_pmax = max(new_pmax, val) - person = self.dbase.get_person_from_handle(pid, self.trans) + person = self.dbase.get_person_from_handle(pid, self.trans) - # new ID is not used - if not self.dbase.has_person_handle(new_key): - self.dbase.remove_person(pid, self.trans) - person.set_handle(new_key) - person.set_gramps_id(new_key) - self.dbase.add_person(person, self.trans) - else: - temp = self.dbase.get_person_from_handle(new_key, self.trans) - # same person, just change it - if person == temp: - self.dbase.remove_person(pid, self.trans) - person.set_handle(new_key) - person.set_gramps_id(new_key) - self.dbase.add_person(person, self.trans) - # give up trying to use the refn as a key - else: - pass + # new ID is not used + if not self.dbase.has_person_handle(new_key): + self.dbase.remove_person(pid, self.trans) + person.set_handle(new_key) + person.set_gramps_id(new_key) + self.dbase.add_person(person, self.trans) + else: + temp = self.dbase.get_person_from_handle(new_key, self.trans) + # same person, just change it + if person == temp: + self.dbase.remove_person(pid, self.trans) + person.set_handle(new_key) + person.set_gramps_id(new_key) + self.dbase.add_person(person, self.trans) + # give up trying to use the refn as a key + else: + pass - self.dbase.pmap_index = new_pmax + self.dbase.pmap_index = new_pmax #-------------------------------------------------------------------- # @@ -4320,184 +4320,184 @@ class GedcomParser(UpdateCallback): # #-------------------------------------------------------------------- - def parse_change(self, line, obj, level): - """ - CHANGE_DATE:= + def __parse_change(self, line, obj, level): + """ + CHANGE_DATE:= - > n CHAN {1:1} - > +1 DATE {1:1} - > +2 TIME {0:1} - > +1 <> {0:M} + > n CHAN {1:1} + > +1 DATE {1:1} + > +2 TIME {0:1} + > +1 <> {0:M} - The Note structure is ignored, since we have nothing - corresponding in GRAMPS. + The Note structure is ignored, since we have nothing + corresponding in GRAMPS. - Based on the values calculated, attempt to convert to a valid - change time using time.strptime. If this fails (and it shouldn't - unless the value is meaningless and doesn't conform to the GEDCOM - spec), the value is ignored. - """ - tstr = None - dstr = None - - while True: - line = self.get_next() - if self.level_is_finished(line, level): - break - elif line.token == TOKEN_TIME: - tstr = line.data - elif line.token == TOKEN_DATE: - dstr = line.data - elif line.token == TOKEN_NOTE: - self.skip_subordinate_levels(level+1) - else: - self.not_recognized(level+1) + Based on the values calculated, attempt to convert to a valid + change time using time.strptime. If this fails (and it shouldn't + unless the value is meaningless and doesn't conform to the GEDCOM + spec), the value is ignored. + """ + tstr = None + dstr = None + + while True: + line = self.__get_next_line() + if self.__level_is_finished(line, level): + break + elif line.token == TOKEN_TIME: + tstr = line.data + elif line.token == TOKEN_DATE: + dstr = line.data + elif line.token == TOKEN_NOTE: + self.__skip_subordinate_levels(level+1) + else: + self.__not_recognized(level+1) - # Attempt to convert the values to a valid change time - if tstr: - try: - if dstr: - tstruct = time.strptime("%s %s" % (dstr, tstr), - "%d %b %Y %H:%M:%S") - else: - tstruct = time.strptime(tstr, "%d %b %Y") - val = time.mktime(tstruct) - obj.change = val - except ValueError: - # parse of time structure failed, so ignore - pass - + # Attempt to convert the values to a valid change time + if tstr: + try: + if dstr: + tstruct = time.strptime("%s %s" % (dstr, tstr), + "%d %b %Y %H:%M:%S") + else: + tstruct = time.strptime(tstr, "%d %b %Y") + val = time.mktime(tstruct) + obj.change = val + except ValueError: + # parse of time structure failed, so ignore + pass + def build_media_object(self, obj, form, filename, title, note): - if form == "url": - url = RelLib.Url() - url.set_path(filename) - url.set_description(title) - obj.add_url(url) - else: - (valid, path) = self.find_file(filename, self.dir_path) - if not valid: - self.warn(_("Could not import %s") % filename) - path = filename.replace('\\', os.path.sep) - photo_handle = self.media_map.get(path) - if photo_handle == None: - photo = RelLib.MediaObject() - photo.set_path(path) - photo.set_description(title) - full_path = os.path.abspath(path) - if os.path.isfile(full_path): - photo.set_mime_type(Mime.get_type(full_path)) - else: - photo.set_mime_type(MIME_MAP.get(form.lower(),'unknown')) - self.dbase.add_object(photo, self.trans) - self.media_map[path] = photo.handle - else: - photo = self.dbase.get_object_from_handle(photo_handle) - oref = RelLib.MediaRef() - oref.set_reference_handle(photo.handle) - oref.add_note(note) - obj.add_media_reference(oref) + if form == "url": + url = RelLib.Url() + url.set_path(filename) + url.set_description(title) + obj.add_url(url) + else: + (valid, path) = self.__find_file(filename, self.dir_path) + if not valid: + self.warn(_("Could not import %s") % filename) + path = filename.replace('\\', os.path.sep) + photo_handle = self.media_map.get(path) + if photo_handle == None: + photo = RelLib.MediaObject() + photo.set_path(path) + photo.set_description(title) + full_path = os.path.abspath(path) + if os.path.isfile(full_path): + photo.set_mime_type(Mime.get_type(full_path)) + else: + photo.set_mime_type(MIME_MAP.get(form.lower(),'unknown')) + self.dbase.add_object(photo, self.trans) + self.media_map[path] = photo.handle + else: + photo = self.dbase.get_object_from_handle(photo_handle) + oref = RelLib.MediaRef() + oref.set_reference_handle(photo.handle) + oref.add_note(note) + obj.add_media_reference(oref) - def _build_event_pair(self, state, event_type, event_map, description): - """ - n TYPE {0:1} p.* - n DATE {0:1} p.*/* - n <> {0:1} p.* - n <> {0:1} p.* - n AGE {0:1} p.* - n AGNC {0:1} p.* - n CAUS {0:1} p.* - n <> {0:M} p.* - n <> {0:M} p.*,* - n <> {0:M} p. - """ - event = RelLib.Event() - event_ref = RelLib.EventRef() - event.set_gramps_id(self.emapper.find_next()) - event.set_type(event_type) - if description and description != 'Y': - event.set_description(description) - self.dbase.add_event(event, self.trans) + def __build_event_pair(self, state, event_type, event_map, description): + """ + n TYPE {0:1} p.* + n DATE {0:1} p.*/* + n <> {0:1} p.* + n <> {0:1} p.* + n AGE {0:1} p.* + n AGNC {0:1} p.* + n CAUS {0:1} p.* + n <> {0:M} p.* + n <> {0:M} p.*,* + n <> {0:M} p. + """ + event = RelLib.Event() + event_ref = RelLib.EventRef() + event.set_gramps_id(self.emapper.find_next()) + event.set_type(event_type) + if description and description != 'Y': + event.set_description(description) + self.dbase.add_event(event, self.trans) - sub_state = GedcomUtils.CurrentState() - sub_state.level = state.level + 1 - sub_state.event_ref = event_ref - sub_state.event = event - sub_state.person = state.person + sub_state = GedcomUtils.CurrentState() + sub_state.level = state.level + 1 + sub_state.event_ref = event_ref + sub_state.event = event + sub_state.person = state.person - self.parse_level(sub_state, event_map, self.func_undefined) - self.dbase.commit_event(event, self.trans) + self.__parse_level(sub_state, event_map, self.__undefined) + self.dbase.commit_event(event, self.trans) - event_ref.set_reference_handle(event.handle) - return event_ref + event_ref.set_reference_handle(event.handle) + return event_ref - def _build_family_event_pair(self, state, event_type, event_map, - description): - event = RelLib.Event() - event_ref = RelLib.EventRef() - event.set_gramps_id(self.emapper.find_next()) - event.set_type(event_type) - if description and description != 'Y': - event.set_description(description) - self.dbase.add_event(event, self.trans) + def __build_family_event_pair(self, state, event_type, event_map, + description): + event = RelLib.Event() + event_ref = RelLib.EventRef() + event.set_gramps_id(self.emapper.find_next()) + event.set_type(event_type) + if description and description != 'Y': + event.set_description(description) + self.dbase.add_event(event, self.trans) - sub_state = GedcomUtils.CurrentState() - sub_state.family = state.family - sub_state.level = state.level+1 - sub_state.event = event - sub_state.event_ref = event_ref + sub_state = GedcomUtils.CurrentState() + sub_state.family = state.family + sub_state.level = state.level+1 + sub_state.event = event + sub_state.event_ref = event_ref - self.parse_level(sub_state, event_map, self.func_undefined) + self.__parse_level(sub_state, event_map, self.__undefined) - family_event_name(event, state.family) - self.dbase.commit_event(event, self.trans) + family_event_name(event, state.family) + self.dbase.commit_event(event, self.trans) - event_ref.set_reference_handle(event.handle) - return event_ref + event_ref.set_reference_handle(event.handle) + return event_ref def extract_temple(self, line): - def get_code(code): - if LdsUtils.temple_to_abrev.has_key(code): - return code - elif LdsUtils.temple_codes.has_key(code): - return LdsUtils.temple_codes[code] - - code = get_code(line.data) - if code: - return code - - ## Not sure why we do this. Kind of ugly. - code = get_code(line.data.split()[0]) - if code: - return code + def get_code(code): + if LdsUtils.temple_to_abrev.has_key(code): + return code + elif LdsUtils.temple_codes.has_key(code): + return LdsUtils.temple_codes[code] + + code = get_code(line.data) + if code: + return code + + ## Not sure why we do this. Kind of ugly. + code = get_code(line.data.split()[0]) + if code: + return code - ## Okay we have no clue which temple this is. - ## We should tell the user and store it anyway. - self.warn("Invalid temple code '%s'" % (line.data,)) - return line.data + ## Okay we have no clue which temple this is. + ## We should tell the user and store it anyway. + self.warn("Invalid temple code '%s'" % (line.data,)) + return line.data def add_default_source(self, obj): - if self.use_def_src and len(obj.get_source_references()) == 0: - sref = RelLib.SourceRef() - sref.set_reference_handle(self.def_src.handle) - obj.add_source_reference(sref) + if self.use_def_src and len(obj.get_source_references()) == 0: + sref = RelLib.SourceRef() + sref.set_reference_handle(self.def_src.handle) + obj.add_source_reference(sref) def person_event_name(event, person): if event.get_type().is_custom(): - if not event.get_description(): - text = EVENT_PERSON_STR % { - 'event_name' : str(event.get_type()), - 'person' : NameDisplay.displayer.display(person), - } - event.set_description(text) + if not event.get_description(): + text = EVENT_PERSON_STR % { + 'event_name' : str(event.get_type()), + 'person' : NameDisplay.displayer.display(person), + } + event.set_description(text) def family_event_name(event, family): if event.get_type().is_custom(): - if not event.get_description(): - text = EVENT_FAMILY_STR % { - 'event_name' : str(event.get_type()), - 'family' : "", - } - event.set_description(text) + if not event.get_description(): + text = EVENT_FAMILY_STR % { + 'event_name' : str(event.get_type()), + 'family' : "", + } + event.set_description(text) def encode_filename(name):