gedcom-x 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

gedcomx/GedcomX.py

@@ -1,50 +1,72 @@
 DEBUG = False
-import base64
-import json
-import mimetypes
-import re
-import uuid
-import xml.etree.ElementTree as ET
 
-from typing import List, Optional
-from xml.dom import minidom
-from .Address import Address
+import json
+import random
+import string
+
+from typing import Any, Dict, Optional
+
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    GedcomX.py
+ Author:  David J. Cartwright
+ Purpose: Object for working with Gedcom-X Data
+
+ Created: 2025-07-25
+ Updated:
+   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data,
+    id_index functionality, will be used for resolution of Resources
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
 from .Agent import Agent
 from .Attribution import Attribution
-from .Conclusion import Conclusion
-from .Coverage import Coverage
-from .Date import Date, date_to_timestamp
 from .Document import Document
-from .EvidenceReference import EvidenceReference
-from .Exceptions import TagConversionError
-from .Event import Event,EventType,EventRole,EventRoleType
-from .Fact import Fact, FactType, FactQualifier
-from .Gedcom import Gedcom
-from .Gedcom5x import GedcomRecord
-from .Gender import Gender, GenderType
+from .Event import Event
 from .Group import Group
-from .Identifier import Identifier, IdentifierType, make_uid, IdentifierList
+from .Identifier import make_uid
 from .Logging import get_logger
-from .Name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
-from .Note import Note
-from .OnlineAccount import OnlineAccount
 from .Person import Person
 from .PlaceDescription import PlaceDescription
-from .PlaceReference import PlaceReference
-from .Qualifier import Qualifier
 from .Relationship import Relationship, RelationshipType
-from .SourceCitation import SourceCitation
-from .SourceDescription import SourceDescription, ResourceType
-from .SourceReference import SourceReference, KnownSourceReference
-from .Subject import Subject
-from .TextValue import TextValue
-from .TopLevelTypeCollection import TopLevelTypeCollection
 from .Resource import Resource, URI
+from .SourceDescription import ResourceType, SourceDescription
+from .TextValue import TextValue
+#=====================================================================
 
-import_log = get_logger('import')
-convert_log = get_logger('conversion')
 
 def TypeCollection(item_type):
+    """
+    Factory that creates a typed, indexable collection for a specific model class.
+
+    The returned object behaves like:
+      - a container (append/remove, __len__, __getitem__)
+      - an iterator (for item in collection)
+      - a simple query helper via __call__(**field_equals)
+      - a small in-memory index on id, name (see note), and uri
+
+    Parameters
+    ----------
+    item_type : type
+        The class/type that items in this collection must be instances of.
+
+    Returns
+    -------
+    Collection
+        A new, empty collection instance specialized for `item_type`.
+
+    Notes
+    -----
+    - Name indexing is currently disabled (see TODO in `_update_indexes`).
+    - The collection auto-assigns/normalizes an item's `uri.path` based on `item_type`.
+    """
     class Collection:
         def __init__(self):
             self._items = []
@@ -75,8 +97,8 @@ def TypeCollection(item_type):
                 self._id_index[item.id] = item
             
             try:
-                if hasattr(item, '_uri'):
-                    self._uri_index[item._uri.value] = item
+                if hasattr(item, 'uri'):
+                    self._uri_index[item.uri.value] = item
             except AttributeError as e:
                 print(f"type{item}")
                 assert False
@@ -93,7 +115,10 @@ def TypeCollection(item_type):
                     else:
                         self._name_index[name_value] = [item]
             '''
-
+        @property
+        def id_index(self):
+            return self._id_index
+        
         def _remove_from_indexes(self, item):
             # Remove from the id index
             if hasattr(item, 'id'):
@@ -111,12 +136,12 @@ def TypeCollection(item_type):
                             if not self._name_index[name_value]:
                                 del self._name_index[name_value]
 
-        def byName(self, sname: str):
+        def byName(self, sname: str | None):
             # Use the name index for fast lookup
             if sname:
                 sname = sname.strip()
                 return self._name_index.get(sname, [])
-            return None
+            return []
 
         def byId(self, id):
             # Use the id index for fast lookup
@@ -132,12 +157,7 @@ def TypeCollection(item_type):
             if item.uri:
                 item.uri.path  = f'{str(item_type.__name__)}s' if (item.uri.path is None or item.uri.path == "") else item.uri.path
             else:
-                item.uri = URI(path=f'/{item_type.__name__}s/')
-            
-            
-            #if isinstance(item,Agent):
-            #    item._uri._path  = 'Agents'
-            #    print(item._uri._as_dict_)
+                item.uri = URI(path=f'/{item_type.__name__}s/',fragment=item.id)
                 
             self._items.append(item)
             self._update_indexes(item)
@@ -234,6 +254,19 @@ class GedcomX:
 
         self.default_id_generator = make_uid
 
+    @property
+    def contents(self):
+        return {
+            "source_descriptions": len(self.source_descriptions),
+            "persons": len(self.persons),
+            "relationships": len(self.relationships),
+            "agents": len(self.agents),
+            "events": len(self.events),
+            "documents": len(self.documents),
+            "places": len(self.places),
+            "groups": len(self.groups),
+        }
+            
     def add(self,gedcomx_type_object):
         if gedcomx_type_object:
             if isinstance(gedcomx_type_object,Person):
@@ -276,7 +309,7 @@ class GedcomX:
         """
         if person and isinstance(person,Person):
             if person.id is None:
-                person.id =self.personURIgenerator()
+                person.id =self.make_id()
             self.persons.append(item=person)
         else:
             raise ValueError(f'person must be a Person Object not type: {type(person)}')
@@ -287,32 +320,33 @@ class GedcomX:
                 print("Adding unresolved Relationship")
                 self.relationships.append(relationship)
                 return
+            elif isinstance(relationship.person1,Person) and isinstance(relationship.person2,Person):
+
+                if relationship.person1:
+                    if relationship.person1.id is None:
+                        relationship.person1.id = self.make_id()
+                    if not self.persons.byId(relationship.person1.id):
+                        self.persons.append(relationship.person1)
+                    if relationship.person1.id not in self.relationship_table:
+                        self.relationship_table[relationship.person1.id] = []
+                    self.relationship_table[relationship.person1.id].append(relationship)
+                    relationship.person1._add_relationship(relationship)
+                else:
+                    pass
+                
+                if relationship.person2:
+                    if relationship.person2.id is None:
+                        relationship.person2.id = self.make_id() #TODO
+                    if not self.persons.byId(relationship.person2.id):
+                        self.persons.append(relationship.person2)
+                    if relationship.person2.id not in self.relationship_table:
+                        self.relationship_table[relationship.person2.id] = []
+                    self.relationship_table[relationship.person2.id].append(relationship)
+                    relationship.person2._add_relationship(relationship)
+                else:
+                    pass
 
-            if relationship.person1:
-                if relationship.person1.id is None:
-                    relationship.person1.id = self.personURIgenerator()
-                if not self.persons.byId(relationship.person1.id):
-                    self.persons.append(relationship.person1)
-                if relationship.person1.id not in self.relationship_table:
-                    self.relationship_table[relationship.person1.id] = []
-                self.relationship_table[relationship.person1.id].append(relationship)
-                relationship.person1._add_relationship(relationship)
-            else:
-                pass
-            
-            if relationship.person2:
-                if relationship.person2.id is None:
-                    relationship.person2.id = self.personURIgenerator() #TODO
-                if not self.persons.byId(relationship.person2.id):
-                    self.persons.append(relationship.person2)
-                if relationship.person2.id not in self.relationship_table:
-                    self.relationship_table[relationship.person2.id] = []
-                self.relationship_table[relationship.person2.id].append(relationship)
-                relationship.person2._add_relationship(relationship)
-            else:
-                pass
-
-            self.relationships.append(relationship)
+                self.relationships.append(relationship)
         else:
             raise ValueError()
     
@@ -338,18 +372,24 @@ class GedcomX:
             if agent in self.agents:
                 return
             if agent.id is None:
-                agent.id = Agent.default_id_generator()
+                agent.id = make_uid()
             if self.agents.byId(agent.id):
-                raise ValueError
-            print(f'Added Agent with id: {agent.id}')
+                pass #TODO Deal with duplicates
+                #raise ValueError
             self.agents.append(agent)
     
     def add_event(self,event_to_add: Event):
         if event_to_add and isinstance(event_to_add,Event):
+            if event_to_add.id is None: event_to_add.id = make_uid()
             for current_event in self.events:
                 if event_to_add == current_event:
+                    print("DUPLICATE EVENT")
+                    print(event_to_add._as_dict_)
+                    print(current_event._as_dict_)
                     return
             self.events.append(event_to_add)
+        else:
+            raise ValueError
 
     def get_person_by_id(self,id: str):
         filtered = [person for person in self.persons if getattr(person, 'id') == id]
@@ -361,6 +401,53 @@ class GedcomX:
         if filtered: return filtered[0]
         return None        
 
+    @property
+    def id_index(self):
+        combined = {**self.source_descriptions.id_index,
+                    **self.persons.id_index,
+                    **self.relationships.id_index,
+                    **self.agents.id_index,
+                    **self.events.id_index,
+                    **self.documents.id_index,
+                    **self.places.id_index,
+                    **self.groups.id_index
+        }
+        for i in combined.keys():
+            combined[i] = str(type(combined[i]).__name__)
+        return combined
+
+    @property
+    def _as_dict(self) -> dict[str, Any]:
+        type_as_dict: Dict[str, Any] = {}
+
+        if self.persons and len(self.persons) > 0:
+            type_as_dict["persons"] = [person._as_dict_ for person in self.persons]
+
+        if self.source_descriptions:
+            type_as_dict["sourceDescriptions"] = [
+                sd._as_dict_ for sd in self.source_descriptions
+            ]
+
+        if self.relationships:
+            type_as_dict["relationships"] = [
+                rel._as_dict_ for rel in self.relationships
+            ]
+
+        if self.agents:
+            type_as_dict["agents"] = [agent._as_dict_ for agent in self.agents]
+
+        if self.events:
+            type_as_dict["events"] = [event._as_dict_ for event in self.events]
+
+        if self.places:
+            type_as_dict["places"] = [place._as_dict_ for place in self.places]
+
+        if self.documents:
+            type_as_dict["documents"] = [doc._as_dict_ for doc in self.documents]
+
+        return type_as_dict
+
+    @property
     def json(self):
         """
         JSON Representation of the GedcomX Genealogy.
@@ -379,972 +466,35 @@ class GedcomX:
         }
         return json.dumps(gedcomx_json, indent=4)
 
-class Translater():
-    def __init__(self,gedcom: Gedcom) -> None:
-        self.handlers = {}
-        self.gedcom: Gedcom = gedcom
-        self.gedcomx = GedcomX()
-        
-        self.object_stack = []
-        self.object_map = {}
-        self.missing_handler_count = {}
-
-        self.translate()
-
-
-    gedcom_even_to_fact = {
-    # Person Fact Types
-    "ADOP": FactType.Adoption,
-    "CHR": FactType.AdultChristening,
-    "EVEN": FactType.Amnesty,  # and other FactTypes with no direct GEDCOM tag
-    "BAPM": FactType.Baptism,
-    "BARM": FactType.BarMitzvah,
-    "BASM": FactType.BatMitzvah,
-    "BIRT": FactType.Birth,
-    "BIRT, CHR": FactType.Birth,
-    "BLES": FactType.Blessing,
-    "BURI": FactType.Burial,
-    "CAST": FactType.Caste,
-    "CENS": FactType.Census,
-    "CIRC": FactType.Circumcision,
-    "CONF": FactType.Confirmation,
-    "CREM": FactType.Cremation,
-    "DEAT": FactType.Death,
-    "EDUC": FactType.Education,
-    "EMIG": FactType.Emigration,
-    "FCOM": FactType.FirstCommunion,
-    "GRAD": FactType.Graduation,
-    "IMMI": FactType.Immigration,
-    "MIL": FactType.MilitaryService,
-    "NATI": FactType.Nationality,
-    "NATU": FactType.Naturalization,
-    "OCCU": FactType.Occupation,
-    "ORDN": FactType.Ordination,
-    "DSCR": FactType.PhysicalDescription,
-    "PROB": FactType.Probate,
-    "PROP": FactType.Property,
-    "RELI": FactType.Religion,
-    "RESI": FactType.Residence,
-    "WILL": FactType.Will,
-
-    # Couple Relationship Fact Types
-    "ANUL": FactType.Annulment,
-    "DIV": FactType.Divorce,
-    "DIVF": FactType.DivorceFiling,
-    "ENGA": FactType.Engagement,
-    "MARR": FactType.Marriage,
-    "MARB": FactType.MarriageBanns,
-    "MARC": FactType.MarriageContract,
-    "MARL": FactType.MarriageLicense,
-    "SEPA": FactType.Separation,
-
-    # Parent-Child Relationship Fact Types
-    # (Note: Only ADOPTION has a direct GEDCOM tag, others are under "EVEN")
-    "ADOP": FactType.AdoptiveParent
-}
-    
-    gedcom_even_to_evnt = {
-    # Person Fact Types
-    "ADOP": EventType.Adoption,
-    "CHR": EventType.AdultChristening,
-    "BAPM": EventType.Baptism,
-    "BARM": EventType.BarMitzvah,
-    "BASM": EventType.BatMitzvah,
-    "BIRT": EventType.Birth,
-    "BIRT, CHR": EventType.Birth,
-    "BLES": EventType.Blessing,
-    "BURI": EventType.Burial,
-    
-    "CENS": EventType.Census,
-    "CIRC": EventType.Circumcision,
-    "CONF": EventType.Confirmation,
-    "CREM": EventType.Cremation,
-    "DEAT": EventType.Death,
-    "EDUC": EventType.Education,
-    "EMIG": EventType.Emigration,
-    "FCOM": EventType.FirstCommunion,
-    
-    "IMMI": EventType.Immigration,
-    
-    "NATU": EventType.Naturalization,
-    
-    "ORDN": EventType.Ordination,
-    
-
-    # Couple Relationship Fact Types
-    "ANUL": EventType.Annulment,
-    "DIV": EventType.Divorce,
-    "DIVF": EventType.DivorceFiling,
-    "ENGA": EventType.Engagement,
-    "MARR": EventType.Marriage
-    
-}
-    
     @staticmethod
-    def clean_str(text: str) -> str:
-        # Regular expression to match HTML/XML tags
-        if text is None or text.strip() == '':
-            return None
-        clean_text = re.sub(r'<[^>]+>', '', text)
-        
-        return clean_text
-
-    def translate(self):
-        for n, repository in enumerate(self.gedcom.repositories):
-            print(f"Parsing Repository {n}")
-            self.parse_record(repository)
-        print(f"Translated {len(self.gedcomx.agents)} 'REPO' records to Agents")
-        for source in self.gedcom.sources:
-            self.parse_record(source)
-        print(f"Translated {len(self.gedcomx.source_descriptions)} 'SOUR' records to SourceDescription")
-
-        for object in self.gedcom.objects:
-            self.parse_record(object)
-        print(f"Translated {len(self.gedcom.objects)} 'OBJE' records to SourceDescriptions")
-
-        for individual in self.gedcom.individuals:
-            self.parse_record(individual)
-        print(f"Translated {len(self.gedcomx.persons)} 'INDI' records to Persons")
-
-        for key in self.missing_handler_count:
-            print(f"{key}: {self.missing_handler_count[key]}")
-
+    def from_json(data: dict):
+        from .Serialization import Serialization
+        gx = GedcomX()
         
-
-        fam_count = len(self.gedcom.families)
-        for family in self.gedcom.families:
-            self.handle_fam(family)
-        print(f"Translated {fam_count} 'FAM' records to {len(self.gedcomx.relationships)} Relationship")
+        source_descriptions = data.get('sourceDescriptions', [])
+        for source in source_descriptions:
+            gx.add_source_description(Serialization.deserialize(source,SourceDescription))     
         
-        print(f"Translated {len(self.gedcomx.events)} 'EVEN' records to Events")
-
-    def find_urls(self,text: str):
-        # Regular expression pattern to match URLs
-        url_pattern = re.compile(r'https?://[^\s]+')
-        # Find all URLs using the pattern
-        urls = url_pattern.findall(text)
-        return urls
-
-    @property
-    def event_type_conversion_table(self):
-        return {'BIRT':EventType.Birth,
-                'OBIT':FactType.Obituary}
-       
-    def parse_record(self,record: GedcomRecord):
-                
-        handler_name = 'handle_' + record.tag.lower()
-        
-        if hasattr(self,handler_name): 
-            convert_log.info(f'Parsing Record: {record.describe()}')         
-            handler = getattr(self,handler_name)            
-            handler(record)
-        else:
-            if record.tag in self.missing_handler_count:
-                self.missing_handler_count[record.tag] += 1
-            else:
-                self.missing_handler_count[record.tag] = 1
-            
-            convert_log.error(f'Failed Parsing Record: {record.describe()}')
-        for sub_record in record.subRecords():
-            self.parse_record(sub_record)
-    
-    def handle__apid(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].description.add_identifier(Identifier(value=URI.from_url('APID://' + record.value)))
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].add_identifier(Identifier(value=URI.from_url('APID://' + record.value)))
-        else:
-            raise ValueError(f"Could not handle '_APID' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
-
-    def handle__meta(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            gxobject = Note(text=Translater.clean_str(record.value))
-            self.object_map[record.level-1].add_note(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise ValueError(f"Could not handle 'WWW' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
-
-    def handle__wlnk(self, record: GedcomRecord):
-        return self.handle_sour(record)
-
-    def handle_addr(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            # TODO CHeck if URL?
-            if Translater.clean_str(record.value):
-                gxobject = Address(value=Translater.clean_str(record.value))
-            else:
-                gxobject = Address()
-            self.object_map[record.level-1].address = gxobject
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADDR' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr1(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR1' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr2(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street2 = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR2' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr3(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street3 = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR3' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr4(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street4 = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR4' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr5(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street5 = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR5' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_adr6(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].street5 = Translater.clean_str(record.value)        
-        else:
-            raise ValueError(f"I do not know how to handle an 'ADR6' tag for a {type(self.object_map[record.level-1])}")
-        
-    def handle_phon(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].phones.append(Translater.clean_str(record.value))        
-        else:
-            raise ValueError(f"I do not know how to handle an '{record.tag}' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_email(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].emails.append(Translater.clean_str(record.value))        
-        else:
-            raise ValueError(f"I do not know how to handle an '{record.tag}' tag for a {type(self.object_map[record.level-1])}")
-    
-    def handle_fax(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            if Translater.clean_str(record.value):
-                self.object_map[record.level-1].emails.append('FAX:' + Translater.clean_str(record.value))        
-        else:
-            raise ValueError(f"I do not know how to handle an '{record.tag}' tag for a {type(self.object_map[record.level-1])}")
-
-    def handle_adop(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Adoption)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_auth(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            if self.gedcomx.agents.byName(record.value):
-                gxobject = self.gedcomx.agents.byName(record.value)[0]
-            else:
-                gxobject = Agent(names=[TextValue(record.value)])
-                self.gedcomx.add_agent(gxobject)
-            
-            self.object_map[record.level-1].author = gxobject
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_bapm(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Baptism)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_birt(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            #gxobject = Event(type=EventType.BIRTH, roles=[EventRole(person=self.object_map[record.level-1], type=EventRoleType.Principal)])
-            gxobject = Fact(type=FactType.Birth)
-            #self.gedcomx.add_event(gxobject)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_buri(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Burial)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_caln(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].description.add_identifier(Identifier(value=URI.from_url('Call Number:' + record.value)))
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].add_identifier(Identifier(value=URI.from_url('Call Number:' + record.value)))
-        elif isinstance(self.object_map[record.level-1], Agent):
-            pass
-            # TODO Why is GEDCOM so shitty? A callnumber for a repository?
-        else:
-            raise ValueError(f"Could not handle 'CALN' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
-
-    def handle_chan(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].created = Date(record.subRecord('DATE'))
-        elif isinstance(self.object_map[record.level-1], Agent):
-            if self.object_map[record.level-1].attribution is None:
-                gxobject = Attribution()
-                self.object_map[record.level-1].attribution = gxobject
-                self.object_stack.append(gxobject)
-                self.object_map[record.level] = gxobject
-        else:
-            raise ValueError()
-
-    def handle_chr(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Christening)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_city(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            self.object_map[record.level-1].city = Translater.clean_str(record.value)
-        else:
-            raise ValueError(f"I do not know how to handle an 'CITY' tag for a {type(self.object_map[record.level-1])}")
-        
-    def handle_conc(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Note):
-            gxobject = Translater.clean_str(str(record.value))
-            self.object_map[record.level-1].append(gxobject)
-        elif isinstance(self.object_map[record.level-1], Agent):
-            gxobject = str(record.value)
-            self.object_map[record.level-1]._append_to_name(gxobject)
-        elif isinstance(self.object_map[record.level-1], Qualifier):
-            gxobject = str(record.value)
-            self.object_map[record.level-2].append(gxobject)
-        elif isinstance(self.object_map[record.level-1], TextValue):
-            #gxobject = TextValue(value=Translater.clean_str(record.value))
-            self.object_map[record.level-1]._append_to_value(record.value)
-        elif isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].append(record.value)
-        elif isinstance(self.object_map[record.level-1], Fact):
-            self.object_map[record.level-1].notes[0].text += record.value
-            
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_cont(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Note):
-            gxobject = str("\n" + record.value if record.value else '')
-            self.object_map[record.level-1].append(gxobject)
-        elif isinstance(self.object_map[record.level-1], Agent):
-            gxobject = str("\n" + record.value if record.value else '')
-        elif isinstance(self.object_map[record.level-1], Qualifier):
-            gxobject = str("\n" + record.value if record.value else '')
-            self.object_map[record.level-1].append(gxobject)
-        elif isinstance(self.object_map[record.level-1], TextValue):
-            #gxobject = TextValue(value="\n" + record.value)
-            self.object_map[record.level-1]._append_to_value(record.value if record.value else '\n')
-        elif isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].append(record.value)
-        elif isinstance(self.object_map[record.level-1], Address):
-            self.object_map[record.level-1]._append(record.value)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-    
-    def handle_crea(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].created = Date(original=record.subRecord('DATE'))
-            
-        elif isinstance(self.object_map[record.level-1], Agent):
-            if self.object_map[record.level-1].attribution is None:
-                gxobject = Attribution()
-                self.object_map[record.level-1].attribution = gxobject
-                self.object_stack.append(gxobject)
-                self.object_map[record.level] = gxobject
-            else:
-                convert_log.info(f"[{record.tag}] Attribution already exists for SourceDescription with id: {self.object_map[record.level-1].id}")
-        else:
-            raise ValueError(f"Could not handle '{record.tag}' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
-    
-    def handle_ctry(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            self.object_map[record.level-1].country = Translater.clean_str(record.value)
-        else:
-            raise ValueError(f"I do not know how to handle an '{record.tag}' tag for a {type(self.object_map[record.level-1])}")
-     
-    def handle_data(self, record: GedcomRecord) -> None:
-        if record.value != '' and record.value == 'None':
-            assert False
-        self.object_map[record.level] = self.object_map[record.level-1]
-
-    def handle_date(self, record: GedcomRecord):
-        if record.parent.tag == 'PUBL':
-            #gxobject = Date(original=record.value) #TODO Make a parser for solid timestamps
-            #self.object_map[0].published = gxobject
-            #self.object_map[0].published = date_to_timestamp(record.value) if record.value else None 
-            self.object_map[0].published = record.value    
-            #self.object_stack.append(gxobject)
-            #self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Event):
-            self.object_map[record.level-1].date = Date(original=record.value)
-        elif isinstance(self.object_map[record.level-1], Fact):
-            self.object_map[record.level-1].date = Date(original=record.value)
-        elif record.parent.tag == 'DATA' and isinstance(self.object_map[record.level-2], SourceReference):
-            gxobject = Note(text='Date: ' + record.value)
-            self.object_map[record.level-2].description.add_note(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            
-            self.object_map[record.level-1].ctreated = record.value #TODO String to timestamp
-        elif isinstance(self.object_map[record.level-1], Attribution):
-            if record.parent.tag == 'CREA':
-                self.object_map[record.level-1].created = record.value #TODO G7
-            elif record.parent.tag == "CHAN":
-                self.object_map[record.level-1].modified = record.value #TODO G7
-        elif record.parent.tag in ['CREA','CHAN']:
-            pass
-
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_deat(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Death)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_even(self, record: GedcomRecord):
-        # TODO If events in a @S, check if only 1 person matches?
-        if record.value and (not record.value.strip() == ''):
-            values = [value.strip() for value in record.value.split(",")]
-            for value in values:
-                if value in Translater.gedcom_even_to_fact.keys():
-                    if isinstance(self.object_map[record.level-1], Person):
-                        gxobject = Fact(type=Translater.gedcom_even_to_fact[value])
-                        self.object_map[record.level-1].add_fact(gxobject)
-
-                        self.object_stack.append(gxobject)
-                        self.object_map[record.level] = gxobject
-
-                    elif isinstance(self.object_map[record.level-1], SourceDescription):
-                        gxobject = Event(type=Translater.gedcom_even_to_evnt[value],sources=[self.object_map[record.level-1]])
-                        self.gedcomx.add_event(gxobject)
-                        self.object_stack.append(gxobject)
-                        self.object_map[record.level] = gxobject
-                    else:
-                        convert_log.warning(f"Could not convert EVEN '{value}' for object of type {type(self.object_map[record.level-1])} in record {record.describe()}")
-                        return
-                        raise TagConversionError(record=record,levelstack=self.object_map)
-                        assert False
-                        # TODO: Fix, this. making an event to cacth subtags, why are these fact tied to a source? GEDCOM is horrible
-                        gxobject = Event(type=EventType.UNKNOWN)
-                        self.object_stack.append(gxobject)
-                        self.object_map[record.level] = gxobject
-                else:
-                    raise TagConversionError(record=record,levelstack=self.object_map)
-
-        else:
-            possible_fact = FactType.guess(record.subRecord('TYPE')[0].value)
-            if possible_fact:
-                gxobject = Fact(type=possible_fact)
-                self.object_map[record.level-1].add_fact(gxobject)
-
-                self.object_stack.append(gxobject)
-                self.object_map[record.level] = gxobject
-                return
-            elif EventType.guess(record.subRecord('TYPE')[0].value):
-                if isinstance(self.object_map[record.level-1], Person):
-                    gxobject = Event(type=EventType.guess(record.subRecord('TYPE')[0].value), roles=[EventRole(person=self.object_map[record.level-1], type=EventRoleType.Principal)])
-                    self.gedcomx.add_event(gxobject)
-                    self.object_stack.append(gxobject)
-                    self.object_map[record.level] = gxobject
-                return
-            else:
-                if isinstance(self.object_map[record.level-1], Person):
-                    gxobject = Event(type=None, roles=[EventRole(person=self.object_map[record.level-1], type=EventRoleType.Principal)])
-                    gxobject.add_note(Note(subject='Event', text=record.value))
-                    self.gedcomx.add_event(gxobject)
-                    self.object_stack.append(gxobject)
-                    self.object_map[record.level] = gxobject
-                    return
-                    
-                else:
-                    assert False
-
-    def handle_exid(self,record: GedcomRecord):
-        gxobject = Identifier(type=IdentifierType.External,value=[record.value])
-        self.object_map[record.level-1].add_identifier(gxobject)
-
-        self.object_stack.append(gxobject)
-        self.object_map[record.level] = gxobject
-
-    def handle_fam(self, record: GedcomRecord) -> None:
-        if record.tag != 'FAM' or record.level != 0:
-            raise ValueError("Invalid record: Must be a level 0 FAM record")
-
-        husband, wife, children = None, None, []
-
-        husband_record = record.subRecords('HUSB')
-        if husband_record:
-            husband = self.gedcomx.get_person_by_id(husband_record[0].xref)
-
-        wife_record = record.subRecords('WIFE')
-        if wife_record:
-            wife = self.gedcomx.get_person_by_id(wife_record[0].xref)
-
-        children_records = record.subRecords('CHIL')
-        if children_records:
-            for child_record in children_records:
-                child = self.gedcomx.get_person_by_id(child_record.xref)
-                if child:
-                    children.append(child)
-
-        if husband:
-            for child in children:
-                relationship = Relationship(person1=husband, person2=child, type=RelationshipType.ParentChild)
-                self.gedcomx.add_relationship(relationship)
-        if wife:
-            for child in children:
-                relationship = Relationship(person1=wife, person2=child, type=RelationshipType.ParentChild)
-                self.gedcomx.add_relationship(relationship)
-        if husband and wife:
-            relationship = Relationship(person1=husband, person2=wife, type=RelationshipType.Couple)
-            self.gedcomx.add_relationship(relationship)
-
-    def handle_famc(self, record: GedcomRecord) -> None:
-        return
-
-    def handle_fams(self, record: GedcomRecord) -> None:
-        return
-
-    def handle_file(self, record: GedcomRecord):
-        if record.value and record.value.strip() != '':
-            #raise ValueError(f"I did not expect the 'FILE' tag to have a value: {record.value}")
-            #TODO Handle files referenced here
-            ...
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            ...
-        self.object_map[record.level-1].resourceType = ResourceType.DigitalArtifact
-           
-    def handle_form(self, record: GedcomRecord):
-        if record.parent.tag == 'FILE' and isinstance(self.object_map[record.level-2], SourceDescription):
-            if record.value and record.value.strip() != '':
-                mime_type, _ = mimetypes.guess_type('placehold.' + record.value)
-                if mime_type:
-                    self.object_map[record.level-2].mediaType = mime_type
-                else:
-                    print(f"Could not determing mime type from {record.value}")
-        elif isinstance(self.object_map[record.level-1], PlaceDescription):
-            self.object_map[record.level-1].names.append(TextValue(value=record.value))
-        elif record.parent.tag == 'TRAN':
-            pass #TODO
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_givn(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Name):
-            given_name = NamePart(value=record.value, type=NamePartType.Given)
-            self.object_map[record.level-1]._add_name_part(given_name)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_indi(self, record: GedcomRecord):
-        person = Person(id=record.xref.replace('@',''))
-        self.gedcomx.add_person(person)
-        self.object_stack.append(person)
-        self.object_map[record.level] = person
-
-    def handle_immi(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Immigration)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_marr(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Marriage)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_name(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Name.simple(record.value)
-            #gxobject = Name(nameForms=[NameForm(fullText=record.value)], type=NameType.BirthName)
-            self.object_map[record.level-1].add_name(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Agent):
-            gxobject = TextValue(value=record.value)
-            self.object_map[record.level-1].add_name(gxobject)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_note(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            gxobject = Note(text=Translater.clean_str(record.value))
-            self.object_map[record.level-1].add_note(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], SourceReference):
-            gxobject = Note(text=Translater.clean_str(record.value))
-            self.object_map[record.level-1].description.add_note(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Conclusion):
-            gxobject = Note(text=record.value)
-            self.object_map[record.level-1].add_note(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Agent):
-            gxobject = Note(text=record.value)
-            self.object_map[record.level-1].add_note(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Attribution):
-            if self.object_map[record.level-1].changeMessage is None:
-                self.object_map[record.level-1].changeMessage = record.value
-            else:
-                self.object_map[record.level-1].changeMessage = self.object_map[record.level-1].changeMessage + '' + record.value
-
-        else:
-            raise ValueError(f"Could not handle 'NOTE' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
-            assert False
-
-    def handle_nsfx(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Name):
-            surname = NamePart(value=record.value, type=NamePartType.Suffix)
-            self.object_map[record.level-1]._add_name_part(surname)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_occu(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Occupation)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_obje(self, record: GedcomRecord):
-        self.handle_sour(record)
-
-    def handle_page(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].descriptionId = record.value
-            self.object_map[record.level-1].add_qualifier(KnownSourceReference(name=str(KnownSourceReference.Page),value=record.value))
-            
-            #self.object_stack.append(gxobject)
-            #self.object_map[record.level] = gxobject
-            self.object_map[record.level] = self.object_map[record.level-1]
-        else:
-            raise ValueError(f"Could not handle 'PAGE' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
-
-    def handle_plac(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            gxobject = Address(value=record.value)
-            self.object_map[record.level-1].add_address(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Event):
-            if self.gedcomx.places.byName(record.value):
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=self.gedcomx.places.byName(record.value)[0])
-            else:
-                place_des = PlaceDescription(names=[TextValue(value=record.value)])
-                self.gedcomx.add_place_description(place_des)
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=place_des)
-                if len(record.subRecords()) > 0:
-                    self.object_map[record.level]= place_des
-
-        elif isinstance(self.object_map[record.level-1], Fact):
-            if self.gedcomx.places.byName(record.value):
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=self.gedcomx.places.byName(record.value)[0])
-            else:
-                place_des = PlaceDescription(names=[TextValue(value=record.value)])
-                self.gedcomx.add_place_description(place_des)
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=place_des)
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            gxobject = Note(text='Place: ' + record.value)
-            self.object_map[record.level-1].add_note(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_post(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            self.object_map[record.level-1].postalCode = Translater.clean_str(record.value)
-        else:
-            raise ValueError(f"I do not know how to handle an 'POST' tag for a {type(self.object_map[record.level-1])}")   
-    
-    def handle_publ(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            if record.value and self.gedcomx.agents.byName(record.value):
-                gxobject = self.gedcomx.agents.byName(record.value)[0]
-            else:
-                gxobject = Agent(names=[TextValue(record.value)])
-                self.gedcomx.add_agent(gxobject)
-            self.object_map[record.level-1].publisher = gxobject
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_prob(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Probate)
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_uid(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            gxobject = Identifier(value=['UID:' + record.value],type=IdentifierType.Primary)
-            self.object_map[record.level-1].add_identifier(gxobject) #NOTE GC7
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-
-    def handle_refn(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person) or isinstance(self.object_map[record.level-1], SourceDescription):
-            gxobject = Identifier(value=[URI.from_url('Reference Number:' + record.value)])
-            self.object_map[record.level-1].add_identifier(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], Agent):
-            gxobject = Identifier(value=['Reference Number:' + record.value])
-            self.object_map[record.level-1].add_identifier(gxobject) #NOTE GC7
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise ValueError(f"Could not handle 'REFN' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
-
-    def handle_repo(self, record: GedcomRecord):
-
-        if record.level == 0:
-            
-            gxobject = Agent(id=record.xref)
-            self.gedcomx.add_agent(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-            
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            if self.gedcomx.agents.byId(record.xref) is not None:
-                
-                # TODO WHere and what to add this to?
-                gxobject = self.gedcomx.agents.byId(record.xref)
-                self.object_map[record.level-1].repository = gxobject
-                self.object_map[record.level] = gxobject
-
-            else:
-                print(record.describe())
-                raise ValueError()
-                gxobject = Agent(names=[TextValue(record.value)])
-        else:
-            raise ValueError(f"I do not know how to handle 'REPO' tag that is not a top-level, or sub-tag of {type(self.object_map[record.level-1])}")
-            
-
-        self.object_stack.append(gxobject)
-        self.object_map[record.level] = gxobject
-
-    def handle_resi(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.Residence)
-            if record.value and record.value.strip() != '':
-                gxobject.add_note(Note(text=record.value))
-            self.object_map[record.level-1].add_fact(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_rin(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].id = record.value
-            self.object_map[record.level-1].add_note(Note(text=f"Source had RIN: of {record.value}"))
-
-        else:
-            raise ValueError(f"Could not handle 'RIN' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
+        persons = data.get('persons', [])
+        for person in persons:
+            gx.add_person(Serialization.deserialize(person,Person))
         
-    def handle_sex(self, record: GedcomRecord):
+        relationships = data.get('relationships', [])
+        for relationship in relationships:
+            gx.add_relationship(Serialization.deserialize(relationship,Relationship))
         
-        if isinstance(self.object_map[record.level-1], Person):
-            if record.value == 'M':
-                gxobject = Gender(type=GenderType.Male)
-            elif record.value == 'F':
-                gxobject = Gender(type=GenderType.Female)
-            else:
-                gxobject = Gender(type=GenderType.Unknown)
-            self.object_map[record.level-1].gender = gxobject
-            
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        else:
-            assert False
+        agents = data.get('agents', [])
+        for agent in agents:
+            gx.add_agent(Serialization.deserialize(agent,Agent))
 
-    def handle_sour(self, record: GedcomRecord):
-        if record.level == 0 or record.tag == '_WLNK' or (record.level == 0 and record.tag == 'OBJE'):
-            source_description = SourceDescription(id=record.xref.replace('@','') if record.xref else None)
-            self.gedcomx.add_source_description(source_description)
-            self.object_stack.append(source_description)
-            self.object_map[record.level] = source_description
-        else:
-            # This 'SOUR' is a SourceReference
-            if record.xref and record.xref.strip() == '':
-                import_log.warning(f"SOUR points to nothing: {record.describe()}")
-                return False
-            if self.gedcomx.source_descriptions.byId(record.xref):
-                gxobject = SourceReference(descriptionId=record.xref, description=self.gedcomx.source_descriptions.byId(record.xref))
-            else:
-                import_log.warning(f'Could not find source with id: {record.xref}')
-                source_description = SourceDescription(id=record.xref)
-                gxobject = SourceReference(descriptionId=record.value, description=source_description)
-            if isinstance(self.object_map[record.level-1],SourceReference):
-                self.object_map[record.level-1].description.add_source(gxobject)
-            elif record.parent.tag in ['NOTE']:
-                pass
-            else:
-                self.object_map[record.level-1].add_source(gxobject)
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-          
-    def handle_stae(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Address):
-            self.object_map[record.level-1].stateOrProvince = Translater.clean_str(record.value)
-        else:
-            raise ValueError(f"I do not know how to handle an 'STAE' tag for a {type(self.object_map[record.level-1])}")
+        events = data.get('events', [])
+        for event in events:
+            gx.add_event(Serialization.deserialize(event,Event))
         
-    def handle_surn(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Name):
-            surname = NamePart(value=record.value, type=NamePartType.Surname)
-            self.object_map[record.level-1]._add_name_part(surname)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_text(self, record: GedcomRecord):
-        if record.parent.tag == 'DATA':
-            if isinstance(self.object_map[record.level-2], SourceReference):
-                gxobject = TextValue(value=record.value)
-                self.object_map[record.level-2].description.add_description(gxobject)
-                self.object_stack.append(gxobject)
-                self.object_map[record.level] = gxobject
-        elif isinstance(self.object_map[record.level-1], SourceDescription):
-            gxobject = Document(text=record.value)
-            self.object_map[record.level-1].analysis = gxobject
-        else:
-            assert False
-
-    def handle_titl(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], SourceDescription):
-            
-            gxobject = TextValue(value=Translater.clean_str(record.value))
-            self.object_map[record.level-1].add_title(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
+        return gx
         
-        elif record.parent.tag == 'FILE' and isinstance(self.object_map[record.level-2], SourceDescription):
-            gxobject = TextValue(value=record.value)
-            self.object_map[record.level-2].add_title(gxobject)
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
-        elif self.object_map[record.level] and isinstance(self.object_map[record.level], Name):
-            gxobject = NamePart(value=record.value, qualifiers=[NamePartQualifier.Title])
-
-            self.object_map[record.level]._add_name_part(gxobject)
-        else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
-
-    def handle_tran(self, record: GedcomRecord):
-        pass
-
-    def handle_type(self, record: GedcomRecord):
-        # peek to see if event or fact
-        if isinstance(self.object_map[record.level-1], Event):
-            if EventType.guess(record.value):
-                self.object_map[record.level-1].type = EventType.guess(record.value)                
-            else:              
-                self.object_map[record.level-1].type = None
-            self.object_map[record.level-1].add_note(Note(text=Translater.clean_str(record.value)))
-        elif isinstance(self.object_map[record.level-1], Fact):
-            if not self.object_map[record.level-1].type:
-                self.object_map[0].type = FactType.guess(record.value)
-        elif isinstance(self.object_map[record.level-1], Identifier):
-            
-            self.object_map[record.level-1].values.append(Translater.clean_str(record.value))
-            self.object_map[record.level-1].type = IdentifierType.Other
-
-        elif record.parent.tag == 'FORM':
-            if not self.object_map[0].mediaType:
-                self.object_map[0].mediaType = record.value
-
-        else:
-            raise ValueError(f"I do not know how to handle 'TYPE' tag for {type(self.object_map[record.level-1])}")
-
-    def handle__url(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-2], SourceDescription):
-            self.object_map[record.level-2].about = URI.from_url(record.value)
-        else:
-            raise ValueError(f"Could not handle '_URL' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
-            
-    def handle_www(self, record: GedcomRecord):
-        if isinstance(self.object_map[record.level-1], Agent):
-            self.object_map[record.level-1].homepage = Translater.clean_str(record.value)
-        elif isinstance(self.object_map[record.level-2], SourceReference):
-            self.object_map[record.level-2].description.add_identifier(Identifier(value=URI.from_url(record.value)))
-        else:
-            raise ValueError(f"Could not handle 'WWW' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
-
+    @staticmethod
+    def make_id(length: int = 12) -> str:
+        """Generate a random alphanumeric ID of given length."""
+        alphabet = string.ascii_letters + string.digits
+        return ''.join(random.choices(alphabet, k=length))