# # Gramps - a GTK+/GNOME based genealogy program # # Copyright (C) 2000-2006 Martin Hawlisch, Donald N. Allingham # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # 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 # 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 # # $Id$ "Import from GeneWeb" #------------------------------------------------------------------------- # # standard python modules # #------------------------------------------------------------------------- import re import time from gettext import gettext as _ #------------------------------------------------------------------------ # # Set up logging # #------------------------------------------------------------------------ import logging log = logging.getLogger(".ImportGeneWeb") #------------------------------------------------------------------------- # # GTK/GNOME Modules # #------------------------------------------------------------------------- import gtk import gtk.glade #------------------------------------------------------------------------- # # GRAMPS modules # #------------------------------------------------------------------------- import Errors import RelLib import const from QuestionDialog import ErrorDialog from DateHandler import parser as _dp from PluginUtils import register_import from htmlentitydefs import name2codepoint _date_parse = re.compile('([kmes~?<>]+)?([0-9/]+)([J|H|F])?(\.\.)?([0-9/]+)?([J|H|F])?') _text_parse = re.compile('0\((.*)\)') _mod_map = { '>' : RelLib.Date.MOD_AFTER, '<' : RelLib.Date.MOD_BEFORE, '~' : RelLib.Date.MOD_ABOUT, } _cal_map = { 'J' : RelLib.Date.CAL_JULIAN, 'H' : RelLib.Date.CAL_HEBREW, 'F' : RelLib.Date.CAL_FRENCH, } enable_debug = False #------------------------------------------------------------------------- # # # #------------------------------------------------------------------------- def importData(database, filename, cb=None): global callback try: g = GeneWebParser(database,filename) except IOError,msg: ErrorDialog(_("%s could not be opened\n") % filename,str(msg)) return try: status = g.parse_geneweb_file() except IOError,msg: errmsg = _("%s could not be opened\n") % filename ErrorDialog(errmsg,str(msg)) return #------------------------------------------------------------------------- # For a description of the file format see # http://cristal.inria.fr/~ddr/GeneWeb/en/gwformat.htm #------------------------------------------------------------------------- class GeneWebParser: def __init__(self, dbase, file): self.db = dbase self.f = open(file,"rU") self.filename = file self.encoding = 'iso-8859-1' def get_next_line(self): self.lineno += 1 line = self.f.readline() if line: try: line = unicode(line.strip()) except UnicodeDecodeError: line = unicode(line.strip(),self.encoding) else: line = None return line def parse_geneweb_file(self): self.trans = self.db.transaction_begin("",batch=True) self.db.disable_signals() t = time.time() self.lineno = 0 self.index = 0 self.fam_count = 0 self.indi_count = 0 self.fkeys = [] self.ikeys = {} self.pkeys = {} self.skeys = {} self.current_mode = None self.current_family = None self.current_husband_handle = None self.current_child_birthplace_handle = None self.current_child_source_handle = None try: while 1: line = self.get_next_line() if line == None: break if line == "": continue fields = line.split(" ") self.debug("LINE: %s" %line) if fields[0] == "fam": self.current_mode = "fam" self.read_family_line(line,fields) elif fields[0] == "rel": self.current_mode = "rel" self.read_relationship_person(line,fields) elif fields[0] == "src": self.read_source_line(line,fields) elif fields[0] in ("wit", "wit:"): self.read_witness_line(line,fields) elif fields[0] == "cbp": self.read_children_birthplace_line(line,fields) elif fields[0] == "csrc": self.read_children_source_line(line,fields) elif fields[0] == "beg" and self.current_mode == "fam": self.read_children_lines() elif fields[0] == "beg" and self.current_mode == "rel": self.read_relation_lines() elif fields[0] == "comm": self.read_family_comment(line,fields) elif fields[0] == "notes": self.read_person_notes_lines(line,fields) elif fields[0] == "notes-db": self.read_database_notes_lines(line,fields) elif fields[0] == "end": self.current_mode = None elif fields[0] == "encoding:": self.encoding = fields[1] else: print "parse_geneweb_file(): Token >%s< unknown. line %d skipped: %s" % (fields[0],self.lineno,line) except Errors.GedcomError, err: self.errmsg(str(err)) t = time.time() - t msg = _('Import Complete: %d seconds') % t self.db.transaction_commit(self.trans,_("GeneWeb import")) self.db.enable_signals() self.db.request_rebuild() print msg print "Families: %d" % len(self.fkeys) print "Individuals: %d" % len(self.ikeys) return None def read_family_line(self,line,fields): self.current_husband_handle = None self.current_child_birthplace_handle = None self.current_child_source_handle = None self.current_family = RelLib.Family() self.db.add_family(self.current_family,self.trans) #self.db.commit_family(self.current_family,self.trans) self.fkeys.append(self.current_family.get_handle()) idx = 1; self.debug("\nHusband:") (idx,husband) = self.parse_person(fields,idx,RelLib.Person.MALE,None) if husband: self.current_husband_handle = husband.get_handle() self.current_family.set_father_handle(husband.get_handle()) self.db.commit_family(self.current_family,self.trans) husband.add_family_handle(self.current_family.get_handle()) self.db.commit_person(husband,self.trans) self.debug("Marriage:") idx = self.parse_marriage(fields,idx) self.debug("Wife:") (idx,wife) = self.parse_person(fields,idx,RelLib.Person.FEMALE,None) if wife: self.current_family.set_mother_handle(wife.get_handle()) self.db.commit_family(self.current_family,self.trans) wife.add_family_handle(self.current_family.get_handle()) self.db.commit_person(wife,self.trans) return None def read_relationship_person(self,line,fields): self.debug("\Relationships:") (idx,person) = self.parse_person(fields,1,RelLib.Person.UNKNOWN,None) if person: self.current_relationship_person_handle = person.get_handle() def read_relation_lines(self): if not self.current_relationship_person_handle: print "Unknown person for relationship in line %d!" % self.lineno return None rel_person = self.db.get_person_from_handle(self.current_relationship_person_handle) while 1: line = self.get_next_line() if line == None or line == "end": break if line == "": continue # match relationship type and related person line_re = re.compile("^- ([^:]+): (.*)$") matches = line_re.match(line) if matches: #split related person into fields fields = matches.groups()[1].split(" ") if fields: (idx,asso_p) = self.parse_person(fields,0,RelLib.Person.UNKNOWN,None) pref = RelLib.PersonRef() pref.set_relation(matches.groups()[0]) print("TODO: Handle association types properly") pref.set_reference_handle(asso_p.get_handle()) rel_person.add_person_ref(pref) self.db.commit_person(rel_person,self.trans) else: print "Invalid name of person in line %d" % self.lineno else: print "Invalid relationship in line %d" % self.lineno break self.current_mode = None return None def read_source_line(self,line,fields): if not self.current_family: print "Unknown family of child in line %d!" % self.lineno return None source = self.get_or_create_source(self.decode(fields[1])) self.current_family.add_source_reference(source) self.db.commit_family(self.current_family,self.trans) return None def read_witness_line(self,line,fields): self.debug("Witness:") if fields[1] == "m:": (idx,wit_p) = self.parse_person(fields,2,RelLib.Person.MALE,None) elif fields[1] == "f:": (idx,wit_p) = self.parse_person(fields,2,RelLib.Person.FEMALE,None) else: (idx,wit_p) = self.parse_person(fields,1,None,None) if wit_p: mev = None # search marriage event for evr in self.current_family.get_event_ref_list(): ev = self.db.get_event_from_handle(evr.get_reference_handle()) if ev.get_type() == RelLib.EventType.MARRIAGE: mev = ev # found. if not mev: # No marriage event found create a new one mev = self.create_event(RelLib.EventType.MARRIAGE, None, None, None, None) mar_ref = RelLib.EventRef() mar_ref.set_reference_handle(mev.get_handle()) self.current_family.add_event_ref(mar_ref) wit_ref = RelLib.EventRef() wit_ref.set_role(RelLib.EventRoleType(RelLib.EventRoleType.WITNESS)) wit_ref.set_reference_handle(mev.get_handle()) wit_p.add_event_ref(wit_ref) self.db.commit_person(wit_p,self.trans) return None def read_children_lines(self): father_surname = "Dummy" if not self.current_husband_handle: print "Unknown father for child in line %d!" % self.lineno return None husb = self.db.get_person_from_handle(self.current_husband_handle) father_surname = husb.get_primary_name().get_surname() if not self.current_family: print "Unknown family of child in line %d!" % self.lineno return None while 1: line = self.get_next_line() if line == None: break if line == "": continue fields = line.split(" ") if fields[0] == "-": self.debug("Child:") child = None if fields[1] == "h": (idx,child) = self.parse_person(fields,2,RelLib.Person.MALE,father_surname) elif fields[1] == "f": (idx,child) = self.parse_person(fields,2,RelLib.Person.FEMALE,father_surname) else: (idx,child) = self.parse_person(fields,1,RelLib.Person.UNKNOWN,father_surname) if child: childref = RelLib.ChildRef() childref.set_reference_handle(child.get_handle()) self.current_family.add_child_ref( childref) self.db.commit_family(self.current_family,self.trans) child.add_parent_family_handle( self.current_family.get_handle()) if self.current_child_birthplace_handle: birth = None birth_ref = child.get_birth_ref() if birth_ref: birth = self.db.get_event_from_handle(birth_ref.ref) if not birth: birth = self.create_event(RelLib.EventType.BIRTH) birth_ref = RelLib.EventRef() birth_ref.set_reference_handle(birth.get_handle()) child.set_birth_ref(birth_ref) birth.set_place_handle(self.current_child_birthplace_handle) self.db.commit_event(birth,self.trans) if self.current_child_source_handle: child.add_source_reference(self.current_child_source_handle) self.db.commit_person(child,self.trans) else: break self.current_mode = None return None def read_children_birthplace_line(self,line,fields): cbp = self.get_or_create_place(self.decode(fields[1])) if cbp: self.current_child_birthplace_handle = cbp.get_handle() return None def read_children_source_line(self,line,fields): csrc = self.get_or_create_source(self.decode(fields[1])) self.current_child_source_handle = csrc return None def read_family_comment(self,line,fields): if not self.current_family: print "Unknown family of child in line %d!" % self.lineno return None n = RelLib.Note() n.set(line) self.db.add_note(n,self.trans) self.current_family.add_note(n.handle) self.db.commit_family(self.current_family,self.trans) return None def _read_notes_lines(self,note_tag): note_txt = "" while True: line = self.get_next_line() if line == None: break fields = line.split(" ") if fields[0] == "end" and fields[1] == note_tag: break elif fields[0] == "beg": continue else: if note_txt: note_txt = note_txt + "\n" + line else: note_txt = note_txt + line if note_txt: n = RelLib.Note() n.set(note_txt) self.db.add_note(n,self.trans) return n.handle return None def read_person_notes_lines(self,line,fields): (idx,person) = self.parse_person(fields,1,None,None) note_handle = self._read_notes_lines( fields[0]) if note_handle: person.add_note(note_handle) self.db.commit_person(person,self.trans) def read_database_notes_lines(self,line,fields): note_handle = self._read_notes_lines( fields[0]) def parse_marriage(self,fields,idx): mariageDataRe = re.compile("^[+#-0-9].*$") mar_date = None mar_place = None mar_source = None sep_date = None div_date = None married = 1 engaged = 0 # skip to marriage date in case person contained unmatches tokens #Alex: this failed when fields[idx] was an empty line. Fixed. #while idx < len(fields) and not fields[idx][0] == "+": while idx < len(fields) and not (fields[idx] and fields[idx][0] == "+"): if fields[idx]: print "parse_marriage(): Unknown field: '%s' in line %d!" %(fields[idx],self.lineno) idx = idx + 1 while idx < len(fields) and mariageDataRe.match(fields[idx]): if fields[idx][0] == "+": mar_date = self.parse_date(self.decode(fields[idx])) self.debug(" Married at: %s" % fields[idx]) idx = idx + 1 elif fields[idx][0] == "-": div_date = self.parse_date(self.decode(fields[idx])) self.debug(" Div at: %s" % fields[idx]) idx = idx + 1 elif fields[idx] == "#mp": idx = idx + 1 mar_place = self.get_or_create_place(self.decode(fields[idx])) self.debug(" Marriage place: %s" % fields[idx]) idx = idx + 1 elif fields[idx] == "#ms": idx = idx + 1 mar_source = self.get_or_create_source(self.decode(fields[idx])) self.debug(" Marriage source: %s" % fields[idx]) idx = idx + 1 elif fields[idx] == "#sep": idx = idx + 1 sep_date = self.parse_date(self.decode(fields[idx])) self.debug(" Seperated since: %s" % fields[idx]) idx = idx + 1 elif fields[idx] == "#nm": self.debug(" Are not married.") married = 0 idx = idx + 1 elif fields[idx] == "#noment": self.debug(" Not mentioned.") idx = idx + 1 elif fields[idx] == "#eng": self.debug(" Are engaged.") engaged = 1 idx = idx + 1 else: print "parse_marriage(): Unknown field '%s'for mariage in line %d!" % (fields[idx],self.lineno) idx = idx + 1 if mar_date or mar_place or mar_source: mar = self.create_event(RelLib.EventType.MARRIAGE, None, mar_date, mar_place, mar_source) mar_ref = RelLib.EventRef() mar_ref.set_reference_handle(mar.get_handle()) self.current_family.add_event_ref(mar_ref) if div_date: div = self.create_event(RelLib.EventType.DIVORCE, None, div_date, None, None) div_ref = RelLib.EventRef() div_ref.set_reference_handle(div.get_handle()) self.current_family.add_event_ref(div_ref) if sep_date or engaged: sep = self.create_event(RelLib.EventType.ENGAGEMENT, None, sep_date, None, None) sep_ref = RelLib.EventRef() sep_ref.set_reference_handle(sep.get_handle()) self.current_family.add_event_ref(sep_ref) if not married: self.current_family.set_relationship(RelLib.FamilyRelType(RelLib.FamilyRelType.UNMARRIED)) self.db.commit_family(self.current_family,self.trans) return idx def parse_person(self,fields,idx,gender,father_surname): if not father_surname: if not idx < len(fields): print "Missing surname of person in line %d!" % self.lineno surname ="" else: surname = self.decode(fields[idx]) idx = idx + 1 else: surname = father_surname if not idx < len(fields): print "Missing firstname of person in line %d!" % self.lineno firstname = "" else: firstname = self.decode(fields[idx]) idx = idx + 1 if idx < len(fields) and father_surname: noSurnameRe = re.compile("^[({\[~>~#\[({!].*$") dateRe = re.compile("^[kmes0-9~<>?]+.*$") source = None birth_parsed = False birth_date = None birth_place = None birth_source = None bapt_date = None bapt_place = None bapt_source = None death_date = None death_place = None death_source = None death_cause = None crem_date = None bur_date = None bur_place = None bur_source = None public_name = None firstname_aliases = [] nick_names = [] name_aliases = [] surname_aliases = [] while idx < len(fields) and personDataRe.match(fields[idx]): if fields[idx][0] == '(': self.debug("Public Name: %s" % fields[idx]) public_name = self.decode(fields[idx][1:-1]) idx += 1 elif fields[idx][0] == '{': self.debug("Firstsname Alias: %s" % fields[idx]) firstname_aliases.append(self.decode(fields[idx][1:-1])) idx += 1 elif fields[idx][0] == '[': self.debug("Title: %s" % fields[idx]) titleparts = self.decode(fields[idx][1:-1]).split(":") tname = ttitle = tplace = tstart = tend = tnth = None try: tname = titleparts[0] ttitle = titleparts[1] if( titleparts[2]): tplace = self.get_or_create_place(titleparts[2]) tstart = self.parse_date(titleparts[3]) tend = self.parse_date(titleparts[4]) tnth = titleparts[5] except IndexError: # not all parts are written all the time pass if tnth: # Append title numer to title ttitle = "%s, %s" % (ttitle, tnth) title = self.create_event(RelLib.EventType.NOB_TITLE,ttitle,tstart,tplace) # TODO: Geneweb has a start date and an end date, and therefore # supprts stuff like: FROM about 1955 TO between 1998 and 1999 # gramps only supports one single date ore range. if tname and tname != "*": n = RelLib.Note() n.set(tname) self.db.add_note(n,self.trans) title.add_note( n.handle) title_ref = RelLib.EventRef() title_ref.set_reference_handle(title.get_handle()) person.add_event_ref(title_ref) idx += 1 elif fields[idx] == '#nick': idx += 1 self.debug("Nick Name: %s" % fields[idx]) nick_names.append(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#occu': idx += 1 self.debug("Occupation: %s" % fields[idx]) occu = self.create_event(RelLib.EventType.OCCUPATION,self.decode(fields[idx])) occu_ref = RelLib.EventRef() occu_ref.set_reference_handle(occu.get_handle()) person.add_event_ref(occu_ref) idx += 1 elif fields[idx] == '#alias': idx += 1 self.debug("Name Alias: %s" % fields[idx]) name_aliases.append(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#salias': idx += 1 self.debug("Surname Alias: %s" % fields[idx]) surname_aliases.append(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#image': idx += 1 self.debug("Image: %s" % fields[idx]) idx += 1 elif fields[idx] == '#src': idx += 1 self.debug("Source: %s" % fields[idx]) source = self.get_or_create_source(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#bs': idx += 1 self.debug("Birth Source: %s" % fields[idx]) birth_source = self.get_or_create_source(self.decode(fields[idx])) idx += 1 elif fields[idx][0] == '!': self.debug("Baptize at: %s" % fields[idx]) bapt_date = self.parse_date(self.decode(fields[idx][1:])) idx += 1 elif fields[idx] == '#bp': idx += 1 self.debug("Birth Place: %s" % fields[idx]) birth_place = self.get_or_create_place(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#pp': idx += 1 self.debug("Baptize Place: %s" % fields[idx]) bapt_place = self.get_or_create_place(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#ps': idx += 1 self.debug("Baptize Source: %s" % fields[idx]) bapt_source = self.get_or_create_source(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#dp': idx += 1 self.debug("Death Place: %s" % fields[idx]) death_place = self.get_or_create_place(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#ds': idx += 1 self.debug("Death Source: %s" % fields[idx]) death_source = self.get_or_create_source(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#buri': idx += 1 self.debug("Burial Date: %s" % fields[idx]) try: bur_date = self.parse_date(self.decode(fields[idx])) except IndexError: pass idx += 1 elif fields[idx] == '#crem': idx += 1 self.debug("Cremention Date: %s" % fields[idx]) crem_date = self.parse_date(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#rp': idx += 1 self.debug("Burial Place: %s" % fields[idx]) bur_place = self.get_or_create_place(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#rs': idx += 1 self.debug("Burial Source: %s" % fields[idx]) bur_source = self.get_or_create_source(self.decode(fields[idx])) idx += 1 elif fields[idx] == '#apubl': self.debug("This is a public record") idx += 1 elif fields[idx] == '#apriv': self.debug("This is a private record") person.set_privacy(True) idx += 1 elif fields[idx] == '#h': self.debug("This is a restricted record") #TODO: Gramps does currently not feature this level person.set_privacy(True) idx += 1 elif dateRe.match( fields[idx]): if not birth_parsed: self.debug("Birth Date: %s" % fields[idx]) birth_date = self.parse_date(self.decode(fields[idx])) birth_parsed = True else: self.debug("Death Date: %s" % fields[idx]) death_date = self.parse_date(self.decode(fields[idx])) if fields[idx] == "mj": death_cause = "Died joung" elif fields[idx][0] == "k": death_cause = "Killed" elif fields[idx][0] == "m": death_cause = "Murdered" elif fields[idx][0] == "e": death_cause = "Executed" elif fields[idx][0] == "d": death_cause = "Disappeared" #TODO: Set special death types more properly idx += 1 else: print "parse_person(): Unknown field '%s' for person in line %d!" % (fields[idx],self.lineno) idx += 1 if public_name: name = person.get_primary_name() name.set_type(RelLib.NameType(RelLib.NameType.BIRTH)) person.add_alternate_name(name) name = RelLib.Name() name.set_type(RelLib.NameType(RelLib.NameType.AKA)) name.set_first_name(public_name) name.set_surname(surname) person.set_primary_name(name) for aka in nick_names: name = RelLib.Attribute() name.set_type(RelLib.AttributeType(RelLib.AttributeType.NICKNAME)) name.set_value(aka) person.add_attribute(name) for aka in firstname_aliases: name = RelLib.Name() name.set_type(RelLib.NameType(RelLib.NameType.AKA)) name.set_first_name(aka) name.set_surname(surname) person.add_alternate_name(name) for aka in name_aliases: name = RelLib.Name() name.set_type(RelLib.NameType(RelLib.NameType.AKA)) name.set_first_name(aka) name.set_surname(surname) person.add_alternate_name(name) for aka in surname_aliases: name = RelLib.Name() name.set_type(RelLib.NameType(RelLib.NameType.AKA)) if public_name: name.set_first_name(public_name) else: name.set_first_name(firstname) name.set_surname(aka) person.add_alternate_name(name) if source: person.add_source_reference(source) if birth_date or birth_place or birth_source: birth = self.create_event(RelLib.EventType.BIRTH, None, birth_date, birth_place, birth_source) birth_ref = RelLib.EventRef() birth_ref.set_reference_handle( birth.get_handle()) person.set_birth_ref( birth_ref) if bapt_date or bapt_place or bapt_source: babt = self.create_event(RelLib.EventType.BAPTISM, None, bapt_date, bapt_place, bapt_source) babt_ref = RelLib.EventRef() babt_ref.set_reference_handle( babt.get_handle()) person.add_event_ref( babt_ref) if death_date or death_place or death_source or death_cause: death = self.create_event(RelLib.EventType.DEATH, None, death_date, death_place, death_source) if death_cause: death.set_description(death_cause) self.db.commit_event(death,self.trans) death_ref = RelLib.EventRef() death_ref.set_reference_handle( death.get_handle()) person.set_death_ref( death_ref) if bur_date: bur = self.create_event(RelLib.EventType.BURIAL, None, bur_date, bur_place, bur_source) bur_ref = RelLib.EventRef() bur_ref.set_reference_handle( bur.get_handle()) person.add_event_ref( bur_ref) if crem_date: crem = self.create_event(RelLib.EventType.CREMATION, None, crem_date, bur_place, bur_source) crem_ref = RelLib.EventRef() crem_ref.set_reference_handle( crem.get_handle()) person.add_event_ref(crem_ref) self.db.commit_person(person,self.trans) return (idx,person) def parse_date(self,field): if field == "0": return None date = RelLib.Date() matches = _text_parse.match(field) if matches: groups = matches.groups() date.set_as_text(groups[0]) date.set_modifier(RelLib.Date.MOD_TEXTONLY) return date matches = _date_parse.match(field) if matches: groups = matches.groups() mod = _mod_map.get(groups[0],RelLib.Date.MOD_NONE) if groups[3] == "..": mod = RelLib.Date.MOD_SPAN cal2 = _cal_map.get(groups[5],RelLib.Date.CAL_GREGORIAN) sub2 = self.sub_date(groups[4]) else: sub2 = (0,0,0) cal1 = _cal_map.get(groups[2],RelLib.Date.CAL_GREGORIAN) sub1 = self.sub_date(groups[1]) date.set(RelLib.Date.QUAL_NONE,mod, cal1, (sub1[0],sub1[1],sub1[2],None,sub2[0],sub2[1],sub2[2],None)) return date else: return None def sub_date(self,data): vals = data.split('/') if len(vals) == 1: return (0,0,int(vals[0])) elif len(vals) == 2: return (0,int(vals[0]),int(vals[1])) else: return (int(vals[0]),int(vals[1]),int(vals[2])) def create_event(self,type,desc=None,date=None,place=None,source=None): event = RelLib.Event() if type: event.set_type(RelLib.EventType(type)) if desc: event.set_description(desc) if date: event.set_date_object(date) if place: event.set_place_handle(place.get_handle()) if source: event.add_source_reference(source) self.db.add_event(event,self.trans) self.db.commit_event(event,self.trans) return event def get_or_create_person(self,firstname,lastname): person = None mykey = firstname+lastname if mykey in self.ikeys and firstname != "?" and lastname != "?": person = self.db.get_person_from_handle(self.ikeys[mykey]) else: person = RelLib.Person() self.db.add_person(person,self.trans) self.db.commit_person(person,self.trans) self.ikeys[mykey] = person.get_handle() return person def get_or_create_place(self,place_name): place = None if place_name in self.pkeys: place = self.db.get_place_from_handle(self.pkeys[place_name]) else: place = RelLib.Place() place.set_title(place_name) self.db.add_place(place,self.trans) self.db.commit_place(place,self.trans) self.pkeys[place_name] = place.get_handle() return place def get_or_create_source(self,source_name): source = None if source_name in self.skeys: source = self.db.get_source_from_handle(self.skeys[source_name]) else: source = RelLib.Source() source.set_title(source_name) self.db.add_source(source,self.trans) self.db.commit_source(source,self.trans) self.skeys[source_name] = source.get_handle() sref = RelLib.SourceRef() sref.set_reference_handle(source.get_handle()) return sref def decode(self,s): s = s.replace('_',' ') charref_re = re.compile('(&#)(x?)([0-9a-zA-Z]+)(;)') for match in charref_re.finditer(s): try: if match.group(2): # HEX nchar = unichr(int(match.group(3),16)) else: # Decimal nchar = unichr(int(match.group(3))) s = s.replace(match.group(0),nchar) except UnicodeDecodeError: pass # replace named entities entref_re = re.compile('(&)([a-zA-Z]+)(;)') for match in entref_re.finditer(s): try: if match.group(2) in name2codepoint: nchar = unichr(name2codepoint[match.group(2)]) s = s.replace(match.group(0),nchar) except UnicodeDecodeError: pass return( s) def debug( self, txt): if enable_debug: print txt #------------------------------------------------------------------------- # # # #------------------------------------------------------------------------- _mime_type = const.app_geneweb _filter = gtk.FileFilter() _filter.set_name(_('GeneWeb files')) _filter.add_mime_type(_mime_type) _format_name = _('GeneWeb') register_import(importData,_filter,_mime_type,0,_format_name)