gedcom-x 0.5__py3-none-any.whl → 0.5.2__py3-none-any.whl

gedcomx/GedcomX.py

@@ -13,9 +13,10 @@ from .Agent import Agent
 from .Attribution import Attribution
 from .Conclusion import Conclusion
 from .Coverage import Coverage
-from .Date import Date
+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
@@ -23,6 +24,7 @@ from .Gedcom import GedcomRecord
 from .Gender import Gender, GenderType
 from .Group import Group
 from .Identifier import Identifier, IdentifierType
+from .Logging import get_logger
 from .Name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
 from .Note import Note
 from .OnlineAccount import OnlineAccount
@@ -37,7 +39,10 @@ from .SourceReference import SourceReference, KnownSourceReference
 from .Subject import Subject
 from .TextValue import TextValue
 from .TopLevelTypeCollection import TopLevelTypeCollection
-from .URI import URI
+from .Resource import Resource, URI
+
+import_log = get_logger('import')
+convert_log = get_logger('conversion')
 
 def TypeCollection(item_type):
     class Collection:
@@ -108,8 +113,10 @@ def TypeCollection(item_type):
 
         def byName(self, sname: str):
             # Use the name index for fast lookup
-            sname = sname.strip()
-            return self._name_index.get(sname, [])
+            if sname:
+                sname = sname.strip()
+                return self._name_index.get(sname, [])
+            return None
 
         def byId(self, id):
             # Use the id index for fast lookup
@@ -122,7 +129,9 @@ def TypeCollection(item_type):
         def append(self, item):
             if not isinstance(item, item_type):
                 raise TypeError(f"Expected item of type {item_type.__name__}, got {type(item).__name__}")
-            item._uri._path  = f'{str(item_type.__name__)}s' if item._uri._path is None else item._uri._path
+            item.uri.path  = f'{str(item_type.__name__)}s' if (item.uri.path is None or item.uri.path == "") else item.uri.path
+            
+            
             #if isinstance(item,Agent):
             #    item._uri._path  = 'Agents'
             #    print(item._uri._as_dict_)
@@ -163,30 +172,49 @@ def TypeCollection(item_type):
     
         @property
         def _items_as_dict(self) -> dict:
-            print(self.item_type)
-                        
-            #return {f'{str(item_type.__name__)}s': [item._as_dict_ for item in self._items]}
-            return {f'{str(item_type.__name__)}s': [item._as_dict_ for item in self._items]}
-        
-        @property
-        def json(self):
-            return json.dumps(self._as_dict, indent=4)
+            return {f'{str(item_type.__name__)}s':  [item._as_dict_ for item in self._items]}
 
         @property
         def _as_dict_(self):
-            return {"Collection": [item._as_dict_ for item in self._items]}         
+            return {f'{str(item_type.__name__).lower()}s': [item._as_dict_ for item in self._items]}     
+
+        @property
+        def json(self) -> str:
+            
+            return json.dumps(self._as_dict_, indent=4)    
 
     return Collection()
 
 class GedcomX:
+    """
+    Main GedcomX Object representing a Genealogy. Stores collections of Top Level Gedcom-X Types.
+    complies with GEDCOM X Conceptual Model V1 (http://gedcomx.org/conceptual-model/v1)
+
+    Parameters
+    ----------
+    id : str
+        Unique identifier for this Genealogy.
+    attribution : Attribution Object
+        Attribution information for the Genealogy
+    filepath : str
+        Not Implimented.
+    description : str
+        Description of the Genealogy: ex. 'My Family Tree'
+
+    Raises
+    ------
+    ValueError
+        If `id` is not a valid UUID.
+    """
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str = None, attribution: Attribution = None, filepath: str = None) -> None:
+    def __init__(self, id: str = None, attribution: Attribution = None, filepath: str = None, description: str = None) -> None:
         self.id = id
         self.attribution = attribution
 
         self._filepath = None
         
+        self.description = description
         self.source_descriptions = TypeCollection(SourceDescription)
         self.persons = TypeCollection(Person)
         self.relationships = TypeCollection(Relationship)      
@@ -199,7 +227,6 @@ class GedcomX:
         self.person_relationships_lookup = {}
 
     def _add(self,gedcomx_type_object):
-        #print(type(gedcomx_type_object))
         if gedcomx_type_object:
             if isinstance(gedcomx_type_object,Person):
                 self.add_person(gedcomx_type_object)
@@ -228,16 +255,27 @@ class GedcomX:
             raise ValueError(f"When adding a SourceDescription, value must be of type SourceDescription, type {type(sourceDescription)} was provided")
 
     def add_person(self,person: Person):
+        """Add a Person object to the Genealogy
+
+        Args:
+            person: Person Object
+
+        Returns:
+            None
+
+        Raises:
+            ValueError: If `person` is not of type Person.
+        """
         if person and isinstance(person,Person):
             if person.id is None:
                 person.id =self.personURIgenerator()
             self.persons.append(item=person)
         else:
-            raise ValueError()
+            raise ValueError(f'person must be a Person Object not type: {type(person)}')
         
     def add_relationship(self,relationship: Relationship):
         if relationship and isinstance(relationship,Relationship):
-            if isinstance(relationship.person1,URI) and isinstance(relationship.person2,URI):
+            if isinstance(relationship.person1,Resource) and isinstance(relationship.person2,Resource):
                 print("Adding unresolved Relationship")
                 self.relationships.append(relationship)
                 return
@@ -277,9 +315,21 @@ class GedcomX:
             self.places.append(placeDescription)
 
     def add_agent(self,agent: Agent):
+        """Add a Agent object to the Genealogy
+
+        Args:
+            agent: Agent Object
+
+        Returns:
+            None
+
+        Raises:
+            ValueError: If `agent` is not of type Agent.
+        """
         if agent and isinstance(agent,Agent):
+            if agent in self.agents:
+                return
             if agent.id is None:
-                raise("Empty ID")
                 agent.id = Agent.default_id_generator()
             if self.agents.byId(agent.id):
                 raise ValueError
@@ -293,7 +343,7 @@ class GedcomX:
                     return
             self.events.append(event_to_add)
 
-    def person(self,id: str):
+    def get_person_by_id(self,id: str):
         filtered = [person for person in self.persons if getattr(person, 'id') == id]
         if filtered: return filtered[0]
         return None
@@ -303,11 +353,23 @@ class GedcomX:
         if filtered: return filtered[0]
         return None        
 
+    def json(self):
+        """
+        JSON Representation of the GedcomX Genealogy.
+
+        Returns:
+            str: JSON Representation of the GedcomX Genealogy in the GEDCOM X JSON Serialization Format
+        """
+        gedcomx_json = {
+            'persons': [person._as_dict_ for person in self.persons],
+            'sourceDescriptions' : [sourceDescription._as_dict_ for sourceDescription in self.source_descriptions]
+        }
+        return json.dumps(gedcomx_json, indent=4)
 
 class Translater():
-    def __init__(self,gedcom) -> None:
+    def __init__(self,gedcom: Gedcom) -> None:
         self.handlers = {}
-        self.gedcom: Gedcom = gedcom if gedcom else None
+        self.gedcom: Gedcom = gedcom
         self.gedcomx = GedcomX()
         
         self.object_stack = []
@@ -316,6 +378,7 @@ class Translater():
 
         self.translate()
 
+
     gedcom_even_to_fact = {
     # Person Fact Types
     "ADOP": FactType.Adoption,
@@ -367,15 +430,55 @@ class Translater():
     "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 repository in self.gedcom.repositories:
+        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:
@@ -402,7 +505,7 @@ class Translater():
         
         print(f"Translated {len(self.gedcomx.events)} 'EVEN' records to Events")
 
-    def find_urls(sef,text: str):
+    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
@@ -411,37 +514,36 @@ class Translater():
 
     @property
     def event_type_conversion_table(self):
-        return {'BIRT':EventType.BIRTH,
-                'OBIT':FactType.OBITUARY}
+        return {'BIRT':EventType.Birth,
+                'OBIT':FactType.Obituary}
        
     def parse_record(self,record: GedcomRecord):
-        
-        if DEBUG: print(record.describe())
+                
         handler_name = 'handle_' + record.tag.lower()
         
-        if hasattr(self,handler_name):
-            
-            handler = getattr(self,handler_name)
+        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
-                if not record.tag.startswith("_"):
-                    print(f"\033[1;31mCould not find handler for GEDCOM tag {record.tag}\n{record.describe()}\033[0m")
+            
+            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):
+    
+    def handle__apid(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1]._description_object.add_identifier(Identifier(value=URI.from_url('APID://' + record.value)))
+            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):
+    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)
@@ -450,14 +552,14 @@ class Translater():
         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):
+    def handle__wlnk(self, record: GedcomRecord):
         return self.handle_sour(record)
 
-    def handle_addr(self, 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 = URI(value=Translater.clean_str(record.value))
+                gxobject = Address(value=Translater.clean_str(record.value))
             else:
                 gxobject = Address()
             self.object_map[record.level-1].address = gxobject
@@ -466,26 +568,80 @@ class Translater():
         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):
+    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)
-                
+                self.object_map[record.level-1].street = Translater.clean_str(record.value)        
         else:
-            raise ValueError(f"I do not know how to handle an 'ADDR' tag for a {type(self.object_map[record.level-1])}")
+            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):
+    def handle_adop(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], Person):
-            gxobject = Fact(type=FactType.ADOPTION)
+            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:
-            print("Cannot translate 'BAPM")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_auth(self, record):
+    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]
@@ -497,10 +653,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'AUTH")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_bapm(self, record):
+    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)
@@ -508,10 +663,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'BAPM")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_birt(self, record):
+    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)
@@ -521,10 +675,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'AUTH")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_buri(self, record):
+    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)
@@ -532,10 +685,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'BURI")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_caln(self, record):
+    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):
@@ -546,7 +698,19 @@ class Translater():
         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_chr(self, record):
+    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)
@@ -554,16 +718,15 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'CHR")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_city(self, record):
+    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):
+    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)
@@ -582,69 +745,85 @@ class Translater():
             self.object_map[record.level-1].notes[0].text += record.value
             
         else:
-            print(f"Cannot translate 'CONC', {self.object_map[record.level-1]}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_cont(self, record):
+    def handle_cont(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], Note):
-            gxobject = str("\n" + record.value)
+            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)
+            gxobject = str("\n" + record.value if record.value else '')
         elif isinstance(self.object_map[record.level-1], Qualifier):
-            gxobject = str("\n" + record.value)
+            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)
+            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:
-            print(f"Cannot translate 'CONT', {type(self.object_map[record.level-1])}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
     
-    def handle__crea(self, record):
+    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.value)
+            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 '_URL' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
+            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):
+    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 'CTRY' tag for a {type(self.object_map[record.level-1])}")
+            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 != '':
+        if record.value != '' and record.value == 'None':
             assert False
-        self.object_map[record.level] = None
+        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)
-            self.object_map[0].published = gxobject
-
-            self.object_stack.append(gxobject)
-            self.object_map[record.level] = gxobject
+            #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_object.add_note(gxobject)
+            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:
-            print(f"Cannot translate 'DATE {type(self.object_map[record.level-1])}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_deat(self, record):
+    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)
@@ -652,12 +831,11 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'DEAT")
-            assert False
+            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 not record.value.strip() == '':
+        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():
@@ -667,18 +845,21 @@ class Translater():
 
                         self.object_stack.append(gxobject)
                         self.object_map[record.level] = gxobject
-                        print(self.object_map)
+
+                    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:
-                        print(record.describe())
+                        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:
-                    
-
-                    print("This event does not look like a Fact")
+                    raise TagConversionError(record=record,levelstack=self.object_map)
 
         else:
             possible_fact = FactType.guess(record.subRecord('TYPE')[0].value)
@@ -708,6 +889,13 @@ class Translater():
                 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")
@@ -716,16 +904,16 @@ class Translater():
 
         husband_record = record.subRecords('HUSB')
         if husband_record:
-            husband = self.gedcomx.person(husband_record[0].value.replace('@',''))
+            husband = self.gedcomx.get_person_by_id(husband_record[0].xref)
 
         wife_record = record.subRecords('WIFE')
         if wife_record:
-            wife = self.gedcomx.person(wife_record[0].value.replace('@',''))
+            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.person(child_record.value.replace('@',''))
+                child = self.gedcomx.get_person_by_id(child_record.xref)
                 if child:
                     children.append(child)
 
@@ -748,41 +936,43 @@ class Translater():
         return
 
     def handle_file(self, record: GedcomRecord):
-        if record.value.strip() != '':
+        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.strip() != '':
+            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 ValueError(f"I do not know how to translate the 'FORM' tag with value '{record.value}' for a {type(self.object_map[record.level-1])}")
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_givn(self, record):
+    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:
-            print(f"{record.describe()}, Cannot translate 'NAME', {self.object_map[record.level-1]}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_indi(self, record):
+    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):
+    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)
@@ -790,10 +980,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'IMMI")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_marr(self, record):
+    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)
@@ -801,10 +990,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'MARR")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_name(self, record):
+    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)
@@ -816,10 +1004,9 @@ class Translater():
             gxobject = TextValue(value=record.value)
             self.object_map[record.level-1].add_name(gxobject)
         else:
-            print(f"{record.describe()}, Cannot translate 'NAME', {self.object_map[record.level-1]}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_note(self, record):
+    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)
@@ -828,7 +1015,7 @@ class Translater():
             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_object.add_note(gxobject)
+            self.object_map[record.level-1].description.add_note(gxobject)
 
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
@@ -838,19 +1025,30 @@ class Translater():
 
             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):
+    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:
-            print(f"{record.describe()}, Cannot translate 'NSFX', {self.object_map[record.level-1]}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_occu(self, record):
+    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)
@@ -858,13 +1056,12 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'OCCU")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
     def handle_obje(self, record: GedcomRecord):
         self.handle_sour(record)
 
-    def handle_page(self, 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.Page)
@@ -875,7 +1072,7 @@ class Translater():
         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):
+    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)
@@ -889,6 +1086,9 @@ class Translater():
                 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, descriptionRef=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, descriptionRef=self.gedcomx.places.byName(record.value)[0])
@@ -902,18 +1102,17 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'PLACE")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_post(self, record):
+    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):
+    def handle_publ(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], SourceDescription):
-            if self.gedcomx.agents.byName(record.value):
+            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)])
@@ -923,10 +1122,9 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'PUBL")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_prob(self, record):
+    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)
@@ -934,28 +1132,46 @@ class Translater():
             self.object_stack.append(gxobject)
             self.object_map[record.level] = gxobject
         else:
-            print("Cannot translate 'PROB")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_refn(self, record):
+    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):
-            self.object_map[record.level-1].add_identifier(Identifier(value=URI.from_url('Reference Number:' + record.value)))
+            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):
+    def handle_repo(self, record: GedcomRecord):
+
         if record.level == 0:
             
-            gxobject = Agent(id=record.value.replace('@',''))
+            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.value.replace('@','')):
+            if self.gedcomx.agents.byId(record.xref) is not None:
+                
                 # TODO WHere and what to add this to?
-                gxobject = self.gedcomx.agents.byId(record.value)
+                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()
@@ -967,20 +1183,19 @@ class Translater():
         self.object_stack.append(gxobject)
         self.object_map[record.level] = gxobject
 
-    def handle_resi(self, record):
+    def handle_resi(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], Person):
             gxobject = Fact(type=FactType.Residence)
-            if record.value.strip() != '':
+            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:
-            print("Cannot translate 'RESI")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_rin(self, record):
+    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}"))
@@ -1004,51 +1219,59 @@ class Translater():
         else:
             assert False
 
-    def handle_sour(self, record):
+    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)
+            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_object.add_source(gxobject)
-                else:
-                    self.object_map[record.level-1].add_source(gxobject)
+            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):
+          
+    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])}")
         
-    def handle_surn(self, record):
+    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:
-            print(f"{record.describe()}, Cannot translate 'NAME', {self.object_map[record.level-1]}")
-            assert False
+            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_object.add_description(gxobject)
+                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):
+    def handle_titl(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], SourceDescription):
             
             gxobject = TextValue(value=Translater.clean_str(record.value))
@@ -1068,12 +1291,12 @@ class Translater():
 
             self.object_map[record.level]._add_name_part(gxobject)
         else:
-            print(self.object_map)
-            print(self.object_map[record.level])
-            raise ValueError(f"Could not handle 'TITL' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
-            assert False
+            raise TagConversionError(record=record,levelstack=self.object_map)
 
-    def handle_type(self, record):
+    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):
@@ -1084,6 +1307,11 @@ class Translater():
         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
@@ -1091,15 +1319,17 @@ class Translater():
         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):
+    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):
-        if isinstance(self.object_map[record.level-2], SourceReference):
-            self.object_map[record.level-2]._description_object.add_identifier(Identifier(value=URI.from_url(record.value)))
+    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]}")