gramps-gedcom7 0.0.3__tar.gz

gramps_gedcom7-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 David Straub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gramps_gedcom7-0.0.3/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: gramps_gedcom7
+Version: 0.0.3
+Summary: A GEDCOM 7 support library for Gramps genealogy software
+Author-email: David Straub <straub@protonmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/DavidMStraub/gramps-gedcom7
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gramps>=6.0.0
+Requires-Dist: gedcom7>=0.3.0
+Dynamic: license-file
+
+# gramps-gedcom7
+
+A GEDCOM 7 import library for Gramps.

gramps_gedcom7-0.0.3/README.md

@@ -0,0 +1,3 @@
+# gramps-gedcom7
+
+A GEDCOM 7 import library for Gramps.

gramps_gedcom7-0.0.3/gramps_gedcom7/__init__.py

@@ -0,0 +1 @@
+from .importer import import_gedcom

gramps_gedcom7-0.0.3/gramps_gedcom7/event.py

@@ -0,0 +1,110 @@
+"""Process GEDCOM 7 event data."""
+
+from gedcom7 import const as g7const
+from gedcom7 import grammar as g7grammar
+from gedcom7 import types as g7types
+from gedcom7 import util as g7util
+from gramps.gen.lib import Event, EventType, Place, PlaceName
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+
+from . import util
+
+
+def handle_event(
+    structure: g7types.GedcomStructure,
+    xref_handle_map: dict[str, str],
+    event_type_map: dict[str, int],
+) -> tuple[Event, list[BasicPrimaryObject]]:
+    """Convert a GEDCOM event structure to a Gramps Event object.
+
+    Args:
+        structure: The GEDCOM structure containing the event data.
+        xref_handle_map: A map of XREFs to Gramps handles.
+        event_type_map: A mapping of GEDCOM event tags to Gramps EventType values.
+
+    Returns:
+        A tuple containing the Gramps Event object and a list of additional objects created.
+    """
+    event = Event()
+    event.set_type(event_type_map.get(structure.tag, EventType.CUSTOM))
+    event.handle = util.make_handle()
+    objects = []
+    for child in structure.children:
+        if child.tag == g7const.SNOTE and child.pointer != g7grammar.voidptr:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            event.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            event, note = util.add_note_to_object(child, event)
+            objects.append(note)
+        # TODO handle media
+        # TODO handle source citation
+        elif child.tag == g7const.PLAC:
+            place, other_objects = handle_place(child, xref_handle_map)
+            event.set_place_handle(place.handle)
+            objects.append(place)
+            objects.extend(other_objects)
+        elif child.tag == g7const.DATE:
+            assert isinstance(
+                child.value,
+                (
+                    g7types.Date,
+                    g7types.DatePeriod,
+                    g7types.DateApprox,
+                    g7types.DateRange,
+                ),
+            ), "Expected value to be a date-related object"
+            date = util.gedcom_date_value_to_gramps_date(child.value)
+            event.set_date_object(date)
+    return event, objects
+
+
+def handle_place(
+    structure: g7types.GedcomStructure,
+    xref_handle_map: dict[str, str],
+) -> tuple[Place, list[BasicPrimaryObject]]:
+    """Convert a GEDCOM place structure to a Gramps Place object.
+
+    Args:
+        structure: The GEDCOM structure containing the place data.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A Gramps Place object created from the GEDCOM structure.
+    """
+    place = Place()
+    objects = []
+    place.handle = util.make_handle()
+    if structure.value:
+        name = PlaceName()
+        name.set_value(structure.value)
+        place.set_name(name)
+    for child in structure.children:
+        if child.tag == g7const.MAP:
+            lat = g7util.get_first_child_with_tag(child, g7const.LATI)
+            lon = g7util.get_first_child_with_tag(child, g7const.LONG)
+            if lat is not None and lon is not None:
+                if not isinstance(lat.value, str) or not isinstance(lon.value, str):
+                    raise ValueError("Latitude and longitude must be strings")
+                place.set_latitude(lat.value)
+                place.set_longitude(lon.value)
+        elif child.tag == g7const.LANG and child.value:
+            place.name.set_language(child.value)
+        elif child.tag == g7const.TRAN:
+            alt_name = PlaceName()
+            alt_name.set_value(child.value)
+            if lang := g7util.get_first_child_with_tag(child, g7const.LANG):
+                alt_name.set_language(lang.value)
+        elif child.tag == g7const.SNOTE and child.pointer != g7grammar.voidptr:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            place.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            place, note = util.add_note_to_object(child, place)
+            # Add the note to the list of objects to be returned
+            objects.append(note)
+    return place, objects

gramps_gedcom7-0.0.3/gramps_gedcom7/family.py

@@ -0,0 +1,100 @@
+"""Handle GEDCOM family records and import them into the Gramps database."""
+
+from typing import List
+
+from gedcom7 import const as g7const
+from gedcom7 import grammar as g7grammar
+from gedcom7 import types as g7types
+from gramps.gen.lib import ChildRef, ChildRefType, Family, MediaRef, EventRef, EventType
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+
+from . import util
+from .event import handle_event
+
+EVENT_TYPE_MAP = {
+    g7const.ANUL: EventType.ANNULMENT,
+    g7const.CENS: EventType.CENSUS,
+    g7const.DIV: EventType.DIVORCE,
+    g7const.DIVF: EventType.DIV_FILING,
+    g7const.ENGA: EventType.ENGAGEMENT,
+    g7const.MARB: EventType.MARR_BANNS,
+    g7const.MARC: EventType.MARR_CONTR,
+    g7const.MARL: EventType.MARR_LIC,
+    g7const.MARS: EventType.MARR_SETTL,
+    g7const.EVEN: EventType.CUSTOM,
+}
+
+
+def handle_family(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle an family record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    family = Family()
+    objects = []
+    for child in structure.children:
+        # TODO handle RESN
+        # TODO handle family attributes
+        if child.tag == g7const.HUSB and child.pointer != g7grammar.voidptr:
+            person_handle = xref_handle_map.get(child.pointer)
+            if not person_handle:
+                raise ValueError(f"Person {child.pointer} not found")
+            family.set_father_handle(person_handle)
+            # TODO handle HUSB PHRASE
+        elif child.tag == g7const.WIFE and child.pointer != g7grammar.voidptr:
+            person_handle = xref_handle_map.get(child.pointer)
+            if not person_handle:
+                raise ValueError(f"Person {child.pointer} not found")
+            family.set_mother_handle(person_handle)
+            # TODO handle WIFE PHRASE
+        elif child.tag == g7const.CHIL and child.pointer != g7grammar.voidptr:
+            person_handle = xref_handle_map.get(child.pointer)
+            if not person_handle:
+                raise ValueError(f"Child {child.pointer} not found")
+            child_ref = ChildRef()
+            child_ref.ref = person_handle
+            family.add_child_ref(child_ref)
+            # TODO handle CHIL PHRASE
+        # TODO handle associations
+        elif child.tag == g7const.SNOTE and child.pointer != g7grammar.voidptr:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            family.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            family, note = util.add_note_to_object(child, family)
+            objects.append(note)
+        # TODO handle source citations
+        # TODO handle indentifier
+        elif child.tag == g7const.OBJE:
+            media_ref = MediaRef()
+            if child.pointer != g7grammar.voidptr:
+                media_handle = xref_handle_map.get(child.pointer)
+                if not media_handle:
+                    raise ValueError(f"Multimedia object {child.pointer} not found")
+                media_ref.ref = media_handle
+                # TODO crop is not implement yet
+                # one complication is that GEDCOM uses pixels, Gramps uses fractions.
+                # Consequently, image dimensions need to be known to convert.
+                family.add_media_reference(media_ref)
+        elif child.tag in EVENT_TYPE_MAP:
+            event, other_objects = handle_event(
+                child, xref_handle_map=xref_handle_map, event_type_map=EVENT_TYPE_MAP
+            )
+            objects.extend(other_objects)
+            event_ref = EventRef()
+            event_ref.ref = event.handle
+            family.add_event_ref(event_ref)
+            objects.append(event)
+    family = util.add_ids(family, structure=structure, xref_handle_map=xref_handle_map)
+    util.set_change_date(structure=structure, obj=family)
+    objects.append(family)
+    return objects

gramps_gedcom7-0.0.3/gramps_gedcom7/header.py

@@ -0,0 +1,15 @@
+"""Handle GEDCOM header records and import them into the Gramps database."""
+
+from gramps.gen.db import DbWriteBase
+from gedcom7 import types as g7types
+
+
+def handle_header(structure: g7types.GedcomStructure, db: DbWriteBase):
+    """Handle a header record and import it into the Gramps database.
+    
+    Args:
+        structure: The GEDCOM header structure to handle.
+        db: The Gramps database to import into.
+    """
+    # TODO: Implement header import
+    pass

gramps_gedcom7-0.0.3/gramps_gedcom7/importer.py

@@ -0,0 +1,35 @@
+"""Import a GEDCOM file into a Gramps database."""
+
+from __future__ import annotations
+
+from gramps.gen.db import DbWriteBase
+import gedcom7
+from pathlib import Path
+from typing import TextIO, BinaryIO
+
+from . import process
+
+
+def import_gedcom(file_input: str | Path | TextIO | BinaryIO, db: DbWriteBase) -> None:
+    """Import a GEDCOM file into a Gramps database.
+
+    Args:
+
+        - file_input: The GEDCOM file to import. This can be a string, Path object, or file-like object.
+        - db: The Gramps database to import the GEDCOM file into.
+    """
+    # Check if file_input is a string or Path object
+    if isinstance(file_input, (str, Path)):
+        with open(file_input, "r", encoding="utf-8") as f:
+            gedcom_data: str = f.read()
+    elif isinstance(file_input, TextIO):
+        gedcom_data = file_input.read()
+    elif isinstance(file_input, BinaryIO):
+        gedcom_data = file_input.read().decode("utf-8")
+    else:
+        raise TypeError(
+            "file_input must be a string, Path object, or file-like object."
+        )
+
+    gedcom_structures = gedcom7.loads(gedcom_data)
+    process.process_gedcom_structures(gedcom_structures, db)

gramps_gedcom7-0.0.3/gramps_gedcom7/individual.py

@@ -0,0 +1,214 @@
+"""Handle GEDCOM individual records and import them into the Gramps database."""
+
+from typing import List
+
+from gedcom7 import const as g7const
+from gedcom7 import grammar as g7grammar
+from gedcom7 import types as g7types
+from gramps.gen.lib import (
+    EventRef,
+    EventType,
+    MediaRef,
+    Name,
+    NameType,
+    Person,
+    Surname,
+)
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+
+from . import util
+from .event import handle_event
+
+GENDER_MAP = {
+    "M": Person.MALE,
+    "F": Person.FEMALE,
+    "U": Person.UNKNOWN,
+    "X": Person.OTHER,
+}
+
+NAME_TYPE_MAP = {
+    "AKA": NameType(NameType.AKA),
+    "BIRTH": NameType(NameType.BIRTH),
+    "MARR": NameType(NameType.MARRIED),
+    "OTHER": NameType(NameType.CUSTOM),
+}
+
+EVENT_TYPE_MAP = {
+    g7const.ADOP: EventType.ADOPT,
+    g7const.BAPM: EventType.BAPTISM,
+    g7const.BARM: EventType.BAR_MITZVAH,
+    g7const.BASM: EventType.BAS_MITZVAH,
+    g7const.BIRT: EventType.BIRTH,
+    g7const.BLES: EventType.BLESS,
+    g7const.BURI: EventType.BURIAL,
+    g7const.CENS: EventType.CENSUS,
+    g7const.CHR: EventType.CHRISTEN,
+    g7const.CHRA: EventType.ADULT_CHRISTEN,
+    g7const.CONF: EventType.CONFIRMATION,
+    g7const.CREM: EventType.CREMATION,
+    g7const.DEAT: EventType.DEATH,
+    g7const.EMIG: EventType.EMIGRATION,
+    g7const.FCOM: EventType.FIRST_COMMUN,
+    g7const.GRAD: EventType.GRADUATION,
+    g7const.IMMI: EventType.IMMIGRATION,
+    g7const.NATU: EventType.NATURALIZATION,
+    g7const.ORDN: EventType.ORDINATION,
+    g7const.PROB: EventType.PROBATE,
+    g7const.RETI: EventType.RETIREMENT,
+    g7const.WILL: EventType.WILL,
+    g7const.EVEN: EventType.CUSTOM,
+}
+
+
+def handle_individual(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle an individual record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    person = Person()
+    objects = []
+    for child in structure.children:
+        # TODO handle RESN
+        if child.tag == g7const.SEX:
+            assert isinstance(child.value, str), "Expected SEX to be a string"
+            try:
+                gender = GENDER_MAP[child.value]
+                person.set_gender(gender)
+            except KeyError:
+                raise ValueError(f"SEX value '{child.value}' is not valid")
+        elif child.tag == g7const.NAME:
+            name, other_objects = handle_name(child, xref_handle_map=xref_handle_map)
+            objects.extend(other_objects)
+            if person.primary_name.is_empty():
+                person.set_primary_name(name)
+            else:
+                person.add_alternate_name(name)
+        # TODO handle attributes
+        # TODO handle SUBM
+        # TODO handle associations
+        # TODO handle ALIA
+        # TODO handle ANCI
+        # TODO handle DESI
+        # TODO handle source citations
+        # TODO handle indentifier
+        elif child.tag == g7const.FAMC and child.pointer != g7grammar.voidptr:
+            family_handle = xref_handle_map.get(child.pointer)
+            if not family_handle:
+                raise ValueError(f"Family {child.pointer} not found")
+            person.add_parent_family_handle(family_handle)
+            # TODO child ref type should be handled in the family!
+            # TODO handle FAMC PHRASE
+        elif child.tag == g7const.FAMS and child.pointer != g7grammar.voidptr:
+            family_handle = xref_handle_map.get(child.pointer)
+            if not family_handle:
+                raise ValueError(f"Family {child.pointer} not found")
+            person.add_family_handle(family_handle)
+            # TODO handle FAMS PHRASE
+        elif child.tag == g7const.SNOTE and child.pointer != g7grammar.voidptr:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            person.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            person, note = util.add_note_to_object(child, person)
+            objects.append(note)
+        elif child.tag == g7const.OBJE:
+            media_ref = MediaRef()
+            if child.pointer != g7grammar.voidptr:
+                media_handle = xref_handle_map.get(child.pointer)
+                if not media_handle:
+                    raise ValueError(f"Multimedia object {child.pointer} not found")
+                media_ref.ref = media_handle
+                # TODO crop is not implement yet
+                # one complication is that GEDCOM uses pixels, Gramps uses fractions.
+                # Consequently, image dimensions need to be known to convert.
+                person.add_media_reference(media_ref)
+        elif child.tag in EVENT_TYPE_MAP:
+            event, other_objects = handle_event(
+                child, xref_handle_map=xref_handle_map, event_type_map=EVENT_TYPE_MAP
+            )
+            objects.extend(other_objects)
+            event_ref = EventRef()
+            event_ref.ref = event.handle
+            person.add_event_ref(event_ref)
+            objects.append(event)
+    person = util.add_ids(person, structure=structure, xref_handle_map=xref_handle_map)
+    util.set_change_date(structure=structure, obj=person)
+    objects.append(person)
+    return objects
+
+
+def handle_name(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> tuple[Name, list[BasicPrimaryObject]]:
+    """Convert a GEDCOM structure to a Gramps Name object.
+
+    Args:
+        structure: The GEDCOM structure containing the name data.
+
+    Returns:
+        A tuple containing the Gramps Name object and a list of additional objects created.
+    """
+    name = Name()
+    surname = Surname()
+    objects = []
+    personal_name = structure.value
+    assert isinstance(
+        personal_name, g7types.PersonalName
+    ), "Expected structure value to be a PersonalName"
+    for child in structure.children:
+        if child.tag == g7const.TYPE:
+            assert isinstance(child.value, str), "Expected TYPE value to be a string"
+            gramps_name_type = NAME_TYPE_MAP.get(child.value, NameType.CUSTOM)
+            if gramps_name_type == NameType.CUSTOM:
+                pass  # TODO handle custom name types
+            name.set_type(NameType(gramps_name_type))
+        elif child.tag == g7const.NPFX:
+            assert isinstance(child.value, str), "Expected NPFX value to be a string"
+            name.set_title(child.value)
+        elif child.tag == g7const.GIVN:
+            assert isinstance(child.value, str), "Expected GIVN value to be a string"
+            name.set_first_name(child.value)
+        elif child.tag == g7const.NICK:
+            assert isinstance(child.value, str), "Expected NICK value to be a string"
+            name.set_nick_name(child.value)
+        elif child.tag == g7const.SPFX:
+            assert isinstance(child.value, str), "Expected SPFX value to be a string"
+            surname.set_prefix(child.value)
+        elif child.tag == g7const.SURN:
+            assert isinstance(child.value, str), "Expected SURN value to be a string"
+            surname.set_surname(child.value)
+        elif child.tag == g7const.NSFX:
+            assert isinstance(child.value, str), "Expected NSFX value to be a string"
+            name.set_suffix(child.value)
+        elif child.tag == g7const.SNOTE and child.pointer != g7grammar.voidptr:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            name.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            name, note = util.add_note_to_object(child, name)
+            objects.append(note)
+        # TODO handle source citation
+    # if name parts are not given, use the personal name parts
+    if not name.first_name and personal_name.given:
+        name.set_first_name(personal_name.given)
+    if not surname.surname and personal_name.surname:
+        surname.set_surname(personal_name.surname)
+    if not name.suffix and personal_name.suffix:
+        name.set_suffix(personal_name.suffix)
+    if not surname.is_empty():
+        name.add_surname(surname)
+    # last resort - only single string, no surname markers - take as first name only
+    if name.is_empty():
+        name.set_first_name(personal_name.fullname)
+    return name, objects

gramps_gedcom7-0.0.3/gramps_gedcom7/multimedia.py

@@ -0,0 +1,53 @@
+"""Handle GEDCOM multimedia records and import them into the Gramps database."""
+
+from typing import List
+
+from gedcom7 import const as g7const
+from gedcom7 import types as g7types
+from gedcom7 import util as g7util
+from gramps.gen.lib import Media
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+
+from . import util
+
+
+def handle_multimedia(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle a multimedia record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    media = Media()
+    objects = []
+    for child in structure.children:
+        if child.tag == g7const.SNOTE:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            media.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            media, note = util.add_note_to_object(child, media)
+            objects.append(note)
+    # TODO handle RESN
+    # TODO handle multiple files
+    file_structure = g7util.get_first_child_with_tag(structure, g7const.FILE)
+    assert file_structure is not None, "Multimedia structure must have a FILE tag"
+    assert isinstance(file_structure.value, str), "Expected FILE value to be a string"
+    media.set_path(file_structure.value.removeprefix("file://"))
+    form_structure = g7util.get_first_child_with_tag(file_structure, g7const.FORM)
+    assert form_structure is not None, "Multimedia file must have a FORM tag"
+    assert isinstance(
+        form_structure.value, g7types.MediaType
+    ), "Expected FORM value to be a MediaType"
+    media.set_mime_type(form_structure.value.media_type)
+    media = util.add_ids(media, structure=structure, xref_handle_map=xref_handle_map)
+    util.set_change_date(structure=structure, obj=media)
+    objects.append(media)
+    return objects

gramps_gedcom7-0.0.3/gramps_gedcom7/note.py

@@ -0,0 +1,26 @@
+"""Handle GEDCOM shared note records and import them into the Gramps database."""
+
+from typing import List
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+from gedcom7 import types as g7types
+from . import util
+
+
+def handle_shared_note(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle a shared note record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    note = util.structure_to_note(structure)
+    # set note handle and Gramps ID
+    note = util.add_ids(note, structure=structure, xref_handle_map=xref_handle_map)
+    # set last change timestamp
+    util.set_change_date(structure=structure, obj=note)
+    return [note]

gramps_gedcom7-0.0.3/gramps_gedcom7/process.py

@@ -0,0 +1,106 @@
+"""Process GEDCOM structures and import them into the Gramps database."""
+
+from __future__ import annotations
+
+from gedcom7 import const as g7const
+from gedcom7 import types as g7types
+from gramps.gen.db import DbTxn, DbWriteBase
+
+from .family import handle_family
+from .header import handle_header
+from .individual import handle_individual
+from .multimedia import handle_multimedia
+from .note import handle_shared_note
+from .repository import handle_repository
+from .source import handle_source
+from .submitter import handle_submitter
+from .util import make_handle
+
+
+def process_gedcom_structures(
+    gedcom_structures: list[g7types.GedcomStructure], db: DbWriteBase
+):
+    """Process GEDCOM structures and import them into the Gramps database.
+
+    Args:
+        gedcom_structures: The GEDCOM structures to process.
+        db: The Gramps database to import the GEDCOM structures into.
+    """
+    if len(gedcom_structures) < 2:
+        raise ValueError("No GEDCOM structures to process.")
+    first_structure = gedcom_structures[0]
+    if first_structure.tag != g7const.HEAD:
+        raise ValueError(
+            f"First structure must be a HEAD structure, but got {first_structure.tag}"
+        )
+    last_structure = gedcom_structures[-1]
+    if last_structure.tag != g7const.TRLR:
+        raise ValueError(
+            f"Last structure must be a TRLR structure, but got {last_structure.tag}"
+        )
+
+    handle_header(first_structure, db)
+
+    # Create a map of handles to XREFs
+    xref_handle_map = {}
+    for structure in gedcom_structures:
+        if structure.xref and structure.xref not in xref_handle_map:
+            xref_handle_map[structure.xref] = make_handle()
+
+    # Handle the remaining structures (excluding header and trailer)
+    objects = []
+    for structure in gedcom_structures[1:-1]:
+        objects += handle_structure(structure, xref_handle_map=xref_handle_map) or []
+
+    add_objects_to_database(objects, db)
+
+
+def handle_structure(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> list | None:
+    """Handle a single GEDCOM structure and import it into the Gramps database.
+
+    Args:
+        structure: The GEDCOM structure to handle.
+        db: The Gramps database to import the GEDCOM structure into.
+    """
+    if structure.tag == g7const.FAM:
+        return handle_family(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.INDI:
+        return handle_individual(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.OBJE:
+        return handle_multimedia(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.REPO:
+        return handle_repository(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.SNOTE:
+        return handle_shared_note(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.SOUR:
+        return handle_source(structure, xref_handle_map=xref_handle_map)
+    elif structure.tag == g7const.SUBM:
+        return handle_submitter(structure)
+    return None
+
+
+def add_objects_to_database(objects, db):
+    with DbTxn("Add child to family", db) as transaction:
+        for obj in objects:
+            if obj.__class__.__name__ == "Person":
+                db.add_person(obj, transaction)
+            elif obj.__class__.__name__ == "Family":
+                db.add_family(obj, transaction)
+            elif obj.__class__.__name__ == "Event":
+                db.add_event(obj, transaction)
+            elif obj.__class__.__name__ == "Citation":
+                db.add_citation(obj, transaction)
+            elif obj.__class__.__name__ == "Source":
+                db.add_source(obj, transaction)
+            elif obj.__class__.__name__ == "Note":
+                db.add_note(obj, transaction)
+            elif obj.__class__.__name__ == "Media":
+                db.add_media(obj, transaction)
+            elif obj.__class__.__name__ == "Place":
+                db.add_place(obj, transaction)
+            elif obj.__class__.__name__ == "Repository":
+                db.add_repository(obj, transaction)
+            elif obj.__class__.__name__ == "Tag":
+                db.add_tag(obj, transaction)

gramps_gedcom7-0.0.3/gramps_gedcom7/repository.py

@@ -0,0 +1,56 @@
+"""Handle GEDCOM repository records and import them into the Gramps database."""
+
+from typing import List
+from gramps.gen.lib import Repository, NoteType, Url, UrlType
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+from gedcom7 import types as g7types, const as g7const, util as g7util
+from . import util
+
+
+def handle_repository(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle a repository record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    repository = Repository()
+    objects = []
+    for child in structure.children:
+        if child.tag == g7const.NAME:
+            # set repository name
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                repository.set_name(child.value)
+        elif child.tag == g7const.SNOTE:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            repository.add_note(note_handle)
+        elif child.tag == g7const.WWW:
+            assert isinstance(child.value, str), "Expected value to be a string"
+            url = Url()
+            url.set_path(child.value)
+            url.set_type(UrlType(UrlType.WEB_HOME))
+            repository.add_url(url)
+        elif child.tag == g7const.EMAIL:
+            assert isinstance(child.value, str), "Expected value to be a string"
+            url = Url()
+            url.set_path(child.value)
+            url.set_type(UrlType(UrlType.EMAIL))
+            repository.add_url(url)
+        elif child.tag == g7const.NOTE:
+            repository, note = util.add_note_to_object(child, repository)
+            objects.append(note)
+    repository = util.add_ids(
+        repository, structure=structure, xref_handle_map=xref_handle_map
+    )
+    util.set_change_date(structure=structure, obj=repository)
+    objects.append(repository)
+    return objects

gramps_gedcom7-0.0.3/gramps_gedcom7/source.py

@@ -0,0 +1,117 @@
+"""Handle GEDCOM source records and import them into the Gramps database."""
+
+from typing import List
+
+from gedcom7 import const as g7const
+from gedcom7 import types as g7types
+from gedcom7 import util as g7util
+from gramps.gen.lib import MediaRef, Note, NoteType, RepoRef, Source, SourceMediaType
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+
+from . import util
+
+MEDIA_TYPE_MAP = {
+    "AUDIO": SourceMediaType.AUDIO,
+    "BOOK": SourceMediaType.BOOK,
+    "CARD": SourceMediaType.CARD,
+    "ELECTRONIC": SourceMediaType.ELECTRONIC,
+    "FICHE": SourceMediaType.FICHE,
+    "FILM": SourceMediaType.FILM,
+    "MAGAZINE": SourceMediaType.MAGAZINE,
+    "MANUSCRIPT": SourceMediaType.MANUSCRIPT,
+    "MAP": SourceMediaType.MAP,
+    "NEWSPAPER": SourceMediaType.NEWSPAPER,
+    "PHOTO": SourceMediaType.PHOTO,
+    "TOMBSTONE": SourceMediaType.TOMBSTONE,
+    "VIDEO": SourceMediaType.VIDEO,
+    "OTHER": SourceMediaType.CUSTOM,
+}
+
+
+def handle_source(
+    structure: g7types.GedcomStructure, xref_handle_map: dict[str, str]
+) -> List[BasicPrimaryObject]:
+    """Handle a source record and convert it to Gramps objects.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+        xref_handle_map: A map of XREFs to Gramps handles.
+
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    source = Source()
+    objects = []
+    for child in structure.children:
+        if child.tag == g7const.TITL:
+            # set source title
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                source.set_title(child.value)
+        elif child.tag == g7const.AUTH:
+            # set source author
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                source.set_author(child.value)
+        elif child.tag == g7const.PUBL:
+            # set source publisher
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                source.set_publication_info(child.value)
+        elif child.tag == g7const.ABBR:
+            # set source abbreviation
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                source.set_abbreviation(child.value)
+        # add the note text as a source note
+        elif child.tag == g7const.TEXT:
+            note = Note()
+            note.type = NoteType(NoteType.SOURCE_TEXT)
+            if child.value is not None:
+                assert isinstance(child.value, str), "Expected value to be a string"
+                note.set(child.value)
+            note.handle = util.make_handle()
+            source.add_note(note.handle)
+        elif child.tag == g7const.REPO:
+            repo_ref = RepoRef()
+            try:
+                repo_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Repository {child.pointer} not found")
+            repo_ref.ref = repo_handle
+            call_number = g7util.get_first_child_with_tag(child, g7const.CALN)
+            if call_number:
+                repo_ref.set_call_number(call_number.value)
+                media_type = g7util.get_first_child_with_tag(call_number, g7const.MEDI)
+                if media_type:
+                    assert isinstance(
+                        media_type.value, str
+                    ), "Expected value to be a string"
+                    gramps_source_media_type = MEDIA_TYPE_MAP.get(
+                        media_type.value, SourceMediaType.CUSTOM
+                    )
+                    repo_ref.set_media_type(SourceMediaType(gramps_source_media_type))
+            source.add_repo_reference(repo_ref)
+        elif child.tag == g7const.SNOTE:
+            try:
+                note_handle = xref_handle_map[child.pointer]
+            except KeyError:
+                raise ValueError(f"Shared note {child.pointer} not found")
+            source.add_note(note_handle)
+        elif child.tag == g7const.NOTE:
+            source, note = util.add_note_to_object(child, source)
+            objects.append(note)
+        elif child.tag == g7const.OBJE:
+            media_ref = MediaRef()
+            media_handle = xref_handle_map.get(child.pointer)
+            if not media_handle:
+                raise ValueError(f"Multimedia object {child.pointer} not found")
+            media_ref.ref = media_handle
+            # TODO crop is not implement yet
+            # one complication is that GEDCOM uses pixels, Gramps uses fractions.
+            # Consequently, image dimensions need to be known to convert.
+            source.add_media_reference(media_ref)
+    source = util.add_ids(source, structure=structure, xref_handle_map=xref_handle_map)
+    util.set_change_date(structure=structure, obj=source)
+    objects.append(source)
+    return objects

gramps_gedcom7-0.0.3/gramps_gedcom7/submitter.py

@@ -0,0 +1,18 @@
+"""Handle GEDCOM submitter records and import them into the Gramps database."""
+
+from typing import List
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+from gedcom7 import types as g7types
+
+
+def handle_submitter(structure: g7types.GedcomStructure) -> List[BasicPrimaryObject]:
+    """Handle a submitter record and convert it to Gramps objects.
+    
+    Args:
+        structure: The GEDCOM submitter structure to handle.
+        
+    Returns:
+        A list of Gramps objects created from the GEDCOM structure.
+    """
+    # TODO: Implement submitter import
+    return []

gramps_gedcom7-0.0.3/gramps_gedcom7/types.py

@@ -0,0 +1,7 @@
+from typing import TypeVar
+
+from gramps.gen.lib.primaryobj import BasicPrimaryObject
+from gramps.gen.lib.notebase import NoteBase
+
+BasicPrimaryObjectT = TypeVar("BasicPrimaryObjectT", bound=BasicPrimaryObject)
+NoteBaseT = TypeVar("NoteBaseT", bound=NoteBase)

gramps_gedcom7-0.0.3/gramps_gedcom7/util.py

@@ -0,0 +1,168 @@
+"""Utility functions for handling GEDCOM 7 data in Gramps."""
+
+from __future__ import annotations
+
+import uuid
+
+from gedcom7 import const as g7const
+from gedcom7 import types as g7types
+from gedcom7 import util as g7util
+from gramps.gen.lib import Date, Note, NoteType
+
+from .types import BasicPrimaryObjectT, NoteBaseT
+
+
+def make_handle() -> str:
+    """Generate a unique handle for a new object."""
+    return uuid.uuid4().hex
+
+
+def add_ids(
+    obj: BasicPrimaryObjectT,
+    structure: g7types.GedcomStructure,
+    xref_handle_map: dict[str, str],
+) -> BasicPrimaryObjectT:
+    """Add a handle and Gramps ID to a new Gramps object."""
+    if not structure.xref or len(structure.xref) < 3:
+        raise ValueError(f"Invalid xref ID: {structure.xref}")
+    if structure.xref not in xref_handle_map:
+        raise ValueError(f"Xref ID {structure.xref} not found in xref_handle_map")
+    obj.handle = xref_handle_map[structure.xref]
+    obj.gramps_id = structure.xref[1:-1]
+    return obj
+
+
+GEDCOM_MONTHS = {
+    "JAN": 1,
+    "FEB": 2,
+    "MAR": 3,
+    "APR": 4,
+    "MAY": 5,
+    "JUN": 6,
+    "JUL": 7,
+    "AUG": 8,
+    "SEP": 9,
+    "OCT": 10,
+    "NOV": 11,
+    "DEC": 12,
+}
+
+
+def set_change_date(
+    structure: g7types.GedcomStructure,
+    obj: BasicPrimaryObjectT,
+) -> BasicPrimaryObjectT:
+    """Set the change date for a Gramps object."""
+    change_structure = g7util.get_first_child_with_tag(structure, g7const.CHAN)
+    if not change_structure:
+        # take creation date as fallback
+        change_structure = g7util.get_first_child_with_tag(structure, g7const.CREA)
+    if not change_structure:
+        # no date found
+        return obj
+    date_structure = g7util.get_first_child_with_tag(change_structure, g7const.DATE)
+    if not date_structure:
+        # no date found
+        return obj
+    assert isinstance(
+        date_structure.value, g7types.DateExact
+    ), "Expected date to be a DateExact object"
+    time_structure = g7util.get_first_child_with_tag(change_structure, g7const.TIME)
+    if time_structure:
+        assert isinstance(
+            time_structure.value, g7types.Time
+        ), "Expected time to be a Time object"
+        time = time_structure.value
+    else:
+        time = None
+    datetime_value = g7util.date_exact_and_time_to_python_datetime(
+        date=date_structure.value,
+        time=time,
+    )
+    obj.change = int(datetime_value.timestamp())
+    return obj
+
+
+def structure_to_note(structure: g7types.GedcomStructure) -> Note:
+    """Create a note from a GEDCOM structure of type NOTE or SNOTE.
+
+    Args:
+        structure: The GEDCOM note structure to handle.
+
+    Returns:
+        A note object.
+    """
+    note = Note()
+    if structure.value is not None:
+        assert isinstance(structure.value, str), "Expected value to be a string"
+        note.set(structure.value)
+    for child in structure.children:
+        # set note type to HTML if MIME type is HTML
+        if child.tag == g7const.MIME:
+            if child.value == g7const.MIME_HTML:
+                note.type = NoteType(NoteType.HTML_CODE)
+        elif child.tag == g7const.TRAN:
+            # iterate over translations - we just append them
+            if child.value is None:
+                continue
+            assert isinstance(child.value, str), "Expected value to be a string"
+            note.append("\n\n" + child.value)
+    return note
+
+
+def add_note_to_object(
+    structure: g7types.GedcomStructure,
+    obj: NoteBaseT,
+) -> tuple[NoteBaseT, Note]:
+    """Add a note to a Gramps object."""
+    note = structure_to_note(structure)
+    note.type = NoteType(NoteType.SOURCE)
+    note.handle = make_handle()
+    # set note change date to parent change date
+    set_change_date(structure=structure, obj=note)
+    obj.add_note(note.handle)
+    return obj, note
+
+
+def get_next_gramps_id(
+    xref_handle_map: dict[str, str],
+    prefix: str,
+) -> str:
+    """Get the next available Gramps ID for a given prefix."""
+    existing_ids = {handle[1:-1] for handle in xref_handle_map.values()}
+    next_id = 1
+    while f"{prefix}{next_id:04d}" in existing_ids:
+        next_id += 1
+    return f"{prefix}{next_id:04d}"
+
+
+CALENDAR_MAP = {
+    "GREGORIAN": Date.CAL_GREGORIAN,
+    "JULIAN": Date.CAL_JULIAN,
+    "HEBREW": Date.CAL_HEBREW,
+    "FRENCH_R": Date.CAL_FRENCH,
+}
+
+
+def gedcom_date_value_to_gramps_date(
+    date_value: g7types.DateValue,
+) -> Date:
+    """Convert a GEDCOM date value to a Gramps date."""
+    date = Date()
+    if isinstance(date_value, g7types.Date):
+        year = date_value.year or 0
+        month = GEDCOM_MONTHS.get(date_value.month or "", 0)
+        day = date_value.day or 0
+        date.set_yr_mon_day(year=year, month=month, day=day)
+        if date_value.calendar is not None and date_value.calendar in CALENDAR_MAP:
+            date.set_calendar(CALENDAR_MAP[date_value.calendar])
+    elif isinstance(date_value, g7types.DatePeriod):
+        # TODO
+        pass
+    elif isinstance(date_value, g7types.DateApprox):
+        # TODO
+        pass
+    elif isinstance(date_value, g7types.DateRange):
+        # TODO
+        pass
+    return date

gramps_gedcom7-0.0.3/gramps_gedcom7.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: gramps_gedcom7
+Version: 0.0.3
+Summary: A GEDCOM 7 support library for Gramps genealogy software
+Author-email: David Straub <straub@protonmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/DavidMStraub/gramps-gedcom7
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gramps>=6.0.0
+Requires-Dist: gedcom7>=0.3.0
+Dynamic: license-file
+
+# gramps-gedcom7
+
+A GEDCOM 7 import library for Gramps.

gramps_gedcom7-0.0.3/gramps_gedcom7.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+gramps_gedcom7/__init__.py
+gramps_gedcom7/event.py
+gramps_gedcom7/family.py
+gramps_gedcom7/header.py
+gramps_gedcom7/importer.py
+gramps_gedcom7/individual.py
+gramps_gedcom7/multimedia.py
+gramps_gedcom7/note.py
+gramps_gedcom7/process.py
+gramps_gedcom7/repository.py
+gramps_gedcom7/source.py
+gramps_gedcom7/submitter.py
+gramps_gedcom7/types.py
+gramps_gedcom7/util.py
+gramps_gedcom7.egg-info/PKG-INFO
+gramps_gedcom7.egg-info/SOURCES.txt
+gramps_gedcom7.egg-info/dependency_links.txt
+gramps_gedcom7.egg-info/requires.txt
+gramps_gedcom7.egg-info/top_level.txt
+test/test_importer.py

gramps_gedcom7-0.0.3/gramps_gedcom7.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gramps_gedcom7-0.0.3/gramps_gedcom7.egg-info/requires.txt

@@ -0,0 +1,2 @@
+gramps>=6.0.0
+gedcom7>=0.3.0

gramps_gedcom7-0.0.3/gramps_gedcom7.egg-info/top_level.txt

@@ -0,0 +1 @@
+gramps_gedcom7

gramps_gedcom7-0.0.3/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gramps_gedcom7"
+version = "0.0.3"
+description = "A GEDCOM 7 support library for Gramps genealogy software"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "David Straub", email = "straub@protonmail.com"},
+]
+dependencies = [
+    "gramps>=6.0.0",
+    "gedcom7>=0.3.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/DavidMStraub/gramps-gedcom7"
+
+[tool.setuptools]
+packages = ["gramps_gedcom7"]

gramps_gedcom7-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gramps_gedcom7-0.0.3/test/test_importer.py

@@ -0,0 +1,10 @@
+from gramps_gedcom7.importer import import_gedcom
+
+from gramps.gen.db.utils import make_database
+
+def test_importer_maximal70():
+    # Test the import_gedcom function with a maximal GEDCOM 7.0 file
+    gedcom_file = "test/data/maximal70.ged"
+    db = make_database("sqlite")
+    db.load(":memory:")
+    import_gedcom(gedcom_file, db)