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

gedcomx/Mutations.py

@@ -0,0 +1,228 @@
+from .Gedcom5x import GedcomRecord
+from .Fact import Fact, FactType
+from .Event import Event, EventType
+
+fact_event_table = {
+    # Person Fact / Event Types
+    "ADOP": {
+        "Fact": FactType.AdoptiveParent,
+        "Event": EventType.Adoption,
+    },
+    "CHR": {
+        "Fact": FactType.AdultChristening,
+        "Event": EventType.AdultChristening,
+    },
+    "EVEN": {
+        "Fact": FactType.Amnesty,
+        # no Event
+    },
+    "BAPM": {
+        "Fact": FactType.Baptism,
+        "Event": EventType.Baptism,
+    },
+    "BARM": {
+        "Fact": FactType.BarMitzvah,
+        "Event": EventType.BarMitzvah,
+    },
+    "BASM": {
+        "Fact": FactType.BatMitzvah,
+        "Event": EventType.BatMitzvah,
+    },
+    "BIRT": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BIRT, CHR": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BLES": {
+        "Fact": FactType.Blessing,
+        "Event": EventType.Blessing,
+    },
+    "BURI": {
+        "Fact": FactType.Burial,
+        "Event": EventType.Burial,
+    },
+    "CAST": {
+        "Fact": FactType.Caste,
+        # no Event
+    },
+    "CENS": {
+        "Fact": FactType.Census,
+        "Event": EventType.Census,
+    },
+    "CIRC": {
+        "Fact": FactType.Circumcision,
+        "Event": EventType.Circumcision,
+    },
+    "CONF": {
+        "Fact": FactType.Confirmation,
+        "Event": EventType.Confirmation,
+    },
+    "CREM": {
+        "Fact": FactType.Cremation,
+        "Event": EventType.Cremation,
+    },
+    "DEAT": {
+        "Fact": FactType.Death,
+        "Event": EventType.Death,
+    },
+    "EDUC": {
+        "Fact": FactType.Education,
+        "Event": EventType.Education,
+    },
+    "EMIG": {
+        "Fact": FactType.Emigration,
+        "Event": EventType.Emigration,
+    },
+    "FCOM": {
+        "Fact": FactType.FirstCommunion,
+        "Event": EventType.FirstCommunion,
+    },
+    "GRAD": {
+        "Fact": FactType.Graduation,
+        # no Event
+    },
+    "IMMI": {
+        "Fact": FactType.Immigration,
+        "Event": EventType.Immigration,
+    },
+    "MIL": {
+        "Fact": FactType.MilitaryService,
+        # no Event
+    },
+    "NATI": {
+        "Fact": FactType.Nationality,
+        # no Event
+    },
+    "NATU": {
+        "Fact": FactType.Naturalization,
+        "Event": EventType.Naturalization,
+    },
+    "OCCU": {
+        "Fact": FactType.Occupation,
+        # no Event
+    },
+    "ORDN": {
+        "Fact": FactType.Ordination,
+        "Event": EventType.Ordination,
+    },
+    "DSCR": {
+        "Fact": FactType.PhysicalDescription,
+        # no Event
+    },
+    "PROB": {
+        "Fact": FactType.Probate,
+        # no Event
+    },
+    "PROP": {
+        "Fact": FactType.Property,
+        # no Event
+    },
+    "RELI": {
+        "Fact": FactType.Religion,
+        # no Event
+    },
+    "RESI": {
+        "Fact": FactType.Residence,
+        # no Event
+    },
+    "WILL": {
+        "Fact": FactType.Will,
+        # no Event
+    },
+
+    # Couple Relationship Fact / Event Types
+    "ANUL": {
+        "Fact": FactType.Annulment,
+        "Event": EventType.Annulment,
+    },
+    "DIV": {
+        "Fact": FactType.Divorce,
+        "Event": EventType.Divorce,
+    },
+    "DIVF": {
+        "Fact": FactType.DivorceFiling,
+        "Event": EventType.DivorceFiling,
+    },
+    "ENGA": {
+        "Fact": FactType.Engagement,
+        "Event": EventType.Engagement,
+    },
+    "MARR": {
+        "Fact": FactType.Marriage,
+        "Event": EventType.Marriage,
+    },
+    "MARB": {
+        "Fact": FactType.MarriageBanns,
+        # no Event
+    },
+    "MARC": {
+        "Fact": FactType.MarriageContract,
+        # no Event
+    },
+    "MARL": {
+        "Fact": FactType.MarriageLicense,
+        # no Event
+    },
+    "MARS":{
+        "Fact":EventType.MarriageSettlment
+
+    },
+    "SEPA": {
+        "Fact": FactType.Separation,
+        # no Event
+    },
+
+}
+
+class GedcomXObject:
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        self.created_with_tag: str = record.tag if record and isinstance(record, GedcomRecord) else None    
+        self.created_at_level: int = record.level if record and isinstance(record, GedcomRecord) else None
+        self.created_at_line_number: int = record.line_number if record and isinstance(record, GedcomRecord) else None
+
+class GedcomXSourceOrDocument(GedcomXObject):
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        super().__init__(record)
+        self.title: str = None
+        self.citation: str = None
+        self.page: str = None
+        self.contributor: str = None
+        self.publisher: str = None
+        self.rights: str = None
+        self.url: str = None
+        self.medium: str = None
+        self.type: str = None
+        self.format: str = None
+        self.created: str = None
+        self.modified: str = None
+        self.language: str = None
+        self.relation: str = None
+        self.identifier: str = None
+        self.description: str = None
+
+class GedcomXEventOrFact(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+        super().__init__(record)
+        if record.tag in fact_event_table.keys():
+
+            if 'Fact' in fact_event_table[record.tag].keys():
+                obj = Fact(type=fact_event_table[record.tag]['Fact'])
+                return obj
+            elif 'Event' in fact_event_table[record.tag].keys():
+                obj = Event(type=fact_event_table[record.tag]['Fact'])
+            else:
+                raise ValueError
+        else:
+            raise ValueError(f"{record.tag} not found in map")
+
+class GedcomXRelationshipBuilder(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+        last_relationship = object_stack.get('lastrelationship',None)
+        last_relationship_data = object_stack.get('lastrelationshipdata',None)
+        if not isinstance(last_relationship_data,dict):
+            last_relationship_data = None
+
+        

gedcomx/Name.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import List,Optional
+from typing_extensions import Self
 
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
@@ -220,6 +221,11 @@ class Name(Conclusion):
     
         return name_as_dict
 
+class QuickName():
+    def __new__(cls,name: str) -> Name:
+        obj = Name(nameForms=[NameForm(fullText=name)])
+        return obj
+    
 def ensure_list(val):
     if val is None:
         return []

gedcomx/Person.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import List, Optional
+from urllib.parse import urljoin
 
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
@@ -8,13 +9,14 @@ from .EvidenceReference import EvidenceReference
 from .Fact import Fact, FactType
 from .Gender import Gender, GenderType
 from .Identifier import IdentifierList
-from .Name import Name
+from .Name import Name, QuickName
 from .Note import Note
 from .SourceReference import SourceReference
+from .Serialization import Serialization
 from .Subject import Subject
 from .Resource import Resource
 from collections.abc import Sized
-from ._Links import _LinkList
+from .Extensions.rs10.rsLink import _rsLinkList
 
 class Person(Subject):
     """A person in the system.
@@ -47,9 +49,10 @@ class Person(Subject):
              names: Optional[List[Name]] = None,
              facts: Optional[List[Fact]] = None,
              living: Optional[bool] = False,
-             links: Optional[_LinkList] = None) -> None:
+             links: Optional[_rsLinkList] = None,
+             uri: Optional[Resource] = None) -> None:
         # Call superclass initializer if needed
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers,links=links)
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers,links=links,uri=uri)
         
         # Initialize mutable attributes to empty lists if None
         self.sources = sources if sources is not None else []
@@ -108,103 +111,59 @@ class Person(Subject):
 
     @property
     def _as_dict_(self):
-        def _serialize(value):
-            if isinstance(value, (str, int, float, bool, type(None))):
-                return value
-            elif isinstance(value, dict):
-                return {k: _serialize(v) for k, v in value.items()}
-            elif isinstance(value, (list, tuple, set)):
-                return [_serialize(v) for v in value]
-            elif hasattr(value, "_as_dict_"):
-                return value._as_dict_
-            else:
-                return str(value)  # fallback for unknown objects
-
-        subject_fields = super()._as_dict_  # Start with base class fields
+        type_as_dict = super()._as_dict_  # Start with base class fields
         # Only add Relationship-specific fields
-        subject_fields.update({
+        type_as_dict.update({
             'private': self.private,
             'living': self.living,
             'gender': self.gender._as_dict_ if self.gender else None,
             'names': [name._as_dict_ for name in self.names],
-            'facts': [fact for fact in self.facts],
-            'uri': 'uri: ' + self.uri.value
+            'facts': [fact._as_dict_ for fact in self.facts],
+            'uri': self.uri._as_dict_ if self.uri else None
                            
         })
 
-        # Serialize and exclude None values
-        for key, value in subject_fields.items():
-            if value is not None:
-                subject_fields[key] = _serialize(value)
-
-        # 3) merge and filter out None *at the top level*
-        return {
-                k: v
-                for k, v in subject_fields.items()
-                if v is not None and not (isinstance(v, Sized) and len(v) == 0)
-            }
-        
-        
+        return Serialization.serialize_dict(type_as_dict)
+           
     @classmethod
     def _from_json_(cls, data: dict):
         """
         Create a Person instance from a JSON-dict (already parsed).
         """
-        
-        
-        # Basic scalar fields
-        id_        = data.get('id')
-        lang       = data.get('lang', 'en')
-        private    = data.get('private', False)
-        extracted  = data.get('extracted', False)
-
-        living  = data.get('extracted', False)
-
-        # Complex singletons
-        analysis    = Resource._from_json_(data['analysis']) if data.get('analysis') else None
-        attribution = Attribution._from_json_(data['attribution']) if data.get('attribution') else None
-        confidence  = ConfidenceLevel_from_json_(data['confidence']) if data.get('confidence') else None
-
-        # Gender (string or dict depending on your JSON)
-        gender_json = data.get('gender')
-        if isinstance(gender_json, dict):
-            gender = Gender._from_json_(gender_json)
-        else:
-            # if it's just the enum value
-            gender = Gender(type=GenderType(gender_json)) if gender_json else Gender(type=GenderType.Unknown)
-        
-        
-        sources     = [SourceReference._from_json_(o)   for o in data.get('sources')] if data.get('sources') else None
-        notes       = [Note._from_json_(o)              for o in data.get('notes')] if data.get('notes') else None
-        evidence    = [EvidenceReference._from_json_(o) for o in data.get('evidence')] if data.get('evidence') else None
-        media       = [SourceReference._from_json_(o)   for o in data.get('media')] if data.get('media') else None
-        identifiers = IdentifierList._from_json_(data.get('identifiers'))      if data.get('identifiers') else None
-        names       = [Name._from_json_(o)              for o in data.get('names')] if data.get('names') else None
-        facts       = [Fact._from_json_(o)              for o in data.get('facts')] if data.get('facts') else None
-        links       = _LinkList._from_json_(data.get('links'))     if data.get('links') else None
-
-        # Build the instance
-        inst = cls(
-            id          = id_,
-            lang        = lang,
-            sources     = sources,
-            analysis    = analysis,
-            notes       = notes,
-            confidence  = confidence,
-            attribution = attribution,
-            extracted   = extracted,
-            evidence    = evidence,
-            media       = media,
-            identifiers = identifiers,
-            private     = private,
-            gender      = gender,
-            names       = names,
-            facts       = facts,
-            living      = living,
-            links       = links
-        )
-
-        return inst
+        return Serialization.deserialize(data, Person)
+
+    @classmethod
+    def from_familysearch(cls, pid: str, token: str, *, base_url: Optional[str] = None):
+        """
+        Fetch a single person by PID from FamilySearch and return a Person.
+        - pid: e.g. "KPHP-4B4"
+        - token: OAuth2 access token (Bearer)
+        - base_url: override API base (defaults to settings.FS_API_BASE or prod)
+        """
+        import requests
+        default_base = "https://apibeta.familysearch.org/platform/"
+
+        base = (base_url or default_base).rstrip("/") + "/"
+        url = urljoin(base, f"tree/persons/{pid}")
+
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {token}",
+        }
+
+        resp = requests.get(url, headers=headers, timeout=(5, 30))
+        resp.raise_for_status()
+
+        payload = resp.json()
+        persons = payload.get("persons") or []
+
+        # Prefer exact match on PID, else first item if present
+        person_json = next((p for p in persons if (p.get("id") == pid)), None) or (persons[0] if persons else None)
+        if not person_json:
+            raise ValueError(f"FamilySearch returned no person for PID {pid}")
+
+        # Keep your existing deserialization helper
+        return Serialization.deserialize(person_json, Person)    
 
 class QuickPerson:
     """A GedcomX Person Data Type created with basic information.
@@ -221,7 +180,7 @@ class QuickPerson:
     Raises:
         ValueError: If `id` is not a valid UUID.
     """
-    def __new__(cls, name: Optional[str], dob: Optional[str], dod: Optional[str]):
+    def __new__(cls, name: str, dob: Optional[str] = None, dod: Optional[str] = None):
         # Build facts from args
         facts = []
         if dob:
@@ -230,4 +189,4 @@ class QuickPerson:
             facts.append(Fact(type=FactType.Death, date=Date(original=dod)))
 
         # Return the different class instance
-        return Person(facts=facts, names=[name] if name else None)
+        return Person(facts=facts, names=[QuickName(name=name)] if name else None)

gedcomx/PlaceDescription.py

@@ -17,17 +17,18 @@ class PlaceDescription(Subject):
     identifier = "http://gedcomx.org/v1/PlaceDescription"
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str =None,
+    def __init__(self, id: Optional[str] =None,
                  lang: str = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Resource = None, notes: Optional[List[Note]] =[],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
-                 extracted: bool = None,
-                 evidence: List[EvidenceReference] = None,
-                 media: List[SourceReference] = [],
-                 identifiers: List[IdentifierList] = [],
-                 names: List[TextValue] = [],
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[Resource] = None,
+                 notes: Optional[List[Note]] =None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 extracted: Optional[bool] = None,
+                 evidence: Optional[List[EvidenceReference]] = None,
+                 media: Optional[List[SourceReference]] = None,
+                 identifiers: Optional[IdentifierList] = None,
+                 names: Optional[List[TextValue]] = None,
                  type: Optional[str] = None,
                  place: Optional[URI] = None,
                  jurisdiction: Optional["Resource | PlaceDescription"] = None, # PlaceDescription
@@ -35,6 +36,7 @@ class PlaceDescription(Subject):
                  longitude: Optional[float] = None,
                  temporalDescription: Optional[Date] = None,
                  spatialDescription: Optional[Resource] = None,) -> None:
+        
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
         self.names = names
         self.type = type
@@ -47,8 +49,8 @@ class PlaceDescription(Subject):
 
     @property
     def _as_dict_(self):
-        place_description_dict = super()._as_dict_
-        place_description_dict.update({
+        type_as_dict = super()._as_dict_
+        type_as_dict.update({
             "names": [n for n in self.names] if self.names else None,
             "type": self.type if self.type else None,
             "place": self.place._as_dict_ if self.place else None,
@@ -56,6 +58,13 @@ class PlaceDescription(Subject):
             "latitude": float(self.latitide) if self.latitide else None,
             "longitude": float(self.longitute) if self.longitute else None,
             "temporalDescription": self.temporalDescription if self.temporalDescription else None,
-            "spatialDescription": self.spacialDescription._as_dict_ if self.temporalDescription else None            
+            "spatialDescription": self.spacialDescription._as_dict_ if self.spacialDescription else None            
         })
-        return Serialization.serialize_dict(place_description_dict)    
+        return Serialization.serialize_dict(type_as_dict) 
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a PlaceDescription instance from a JSON-dict (already parsed).
+        """
+        return Serialization.deserialize(data, PlaceDescription)   

gedcomx/PlaceReference.py

@@ -7,27 +7,24 @@ class PlaceReference:
     identifier = 'http://gedcomx.org/v1/PlaceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
     
-    def __init__(self, original: Optional[str], descriptionRef: Optional[Resource]) -> None:
+    def __init__(self,
+                 original: Optional[str] = None,
+                 description: Optional[Resource] = None) -> None:
         self.original = original
-        self.descriptionRef = descriptionRef
+        self.description = description
 
     @property
     def _as_dict_(self):
-        place_reference_dict = {
+        type_as_dict = {
             'original': self.original,
-            'descriptionRef': self.descriptionRef._as_dict_ if isinstance(self.descriptionRef,Resource) else Resource(target=self.descriptionRef)._as_dict_
+            'description': self.description._as_dict_ if self.description else None
             } 
-        return Serialization.serialize_dict(place_reference_dict)
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data):
+        
+        return Serialization.deserialize(data, PlaceReference)
 
-def ensure_list(val):
-    if val is None:
-        return []
-    return val if isinstance(val, list) else [val]
 
-# PlaceReference
-PlaceReference._from_json_ = classmethod(lambda cls, data: PlaceReference(
-    original=data.get('original'),
-    descriptionRef=Resource._from_json_(data['description']) if data.get('description') else None
-))
 
-   

gedcomx/Relationship.py

@@ -35,12 +35,15 @@ class Relationship(Subject):
         person2 (Person): Second Person in Relationship
 
     Raises:
-        ValueError: If `id` is not a valid UUID.
+        
     """
     identifier = 'http://gedcomx.org/v1/Relationship'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, 
+    def __init__(self,
+             person1: Optional[Person | Resource] = None,
+             person2: Optional[Person | Resource] = None,
+             facts: Optional[List[Fact]] = None,  
              id: Optional[str] = None,
              lang: Optional[str] = None,
              sources: Optional[List[SourceReference]] = None,
@@ -53,74 +56,40 @@ class Relationship(Subject):
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[List[Identifier]] = None,
              type: Optional[RelationshipType] = None,
-             person1: Optional[Person | Resource] = None,
-             person2: Optional[Person | Resource] = None,
-             facts: Optional[List[Fact]] = None) -> None:
+             ) -> None:
     
         # Call superclass initializer if required
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
         
-        # Initialize optional parameters with default empty lists if None
-        #self.sources = sources if sources is not None else []
-        #self.notes = notes if notes is not None else []
-        #self.evidence = evidence if evidence is not None else []
-        #self.media = media if media is not None else []
-        #self.identifiers = identifiers if identifiers is not None else []
-        #self.facts = facts if facts is not None else []
-
-        # Initialize other attributes
         self.type = type
         self.person1 = person1
         self.person2 = person2
-        self.facts = facts if facts else None
+        self.facts = facts if facts else []
     
+    def add_fact(self,fact: Fact):
+        if fact is not None and isinstance(fact,Fact):
+            for existing_fact in self.facts:
+                if fact == existing_fact:
+                    return
+            self.facts.append(fact)
+        else:
+            raise TypeError(f"Expected type 'Fact' recieved type {type(fact)}")
+
     @property
     def _as_dict_(self):
-        return serialize_to_dict(self, {
+        type_as_dict = super()._as_dict_
+        type_as_dict.update({
             "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
-            "person1": self.person1.uri,
-            "person2": self.person2.uri,
+            "person1": self.person1._as_dict_ if self.person1 else None,
+            "person2": self.person2._as_dict_ if self.person2 else None,
             "facts": [fact for fact in self.facts] if self.facts else None
         })
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: dict):
         """
-        Create a Relationship instance from a JSON-dict (already parsed).
+        Create a Person instance from a JSON-dict (already parsed).
         """
-        def ensure_list(value):
-            if value is None:
-                return []
-            if isinstance(value, list):
-                return value
-            return [value]  # wrap single item in list
-
-        # Basic scalar fields (adjust as needed)
-        id_        = data.get('id')
-        type_      = data.get('type')
-        extracted  = data.get('extracted', None)
-        private    = data.get('private', None)
-
-        # Complex singletons (adjust as needed)
-        person1    = Resource.from_url(data.get('person1')['resource']) if data.get('person1') else None
-        person2    = Resource.from_url(data.get('person2')['resource']) if data.get('person2') else None
-        facts      = [Fact._from_json_(o) for o in ensure_list(data.get('facts'))]
-        sources    = [SourceReference._from_json_(o) for o in ensure_list(data.get('sources'))]
-        notes      = [Note._from_json_(o) for o in ensure_list(data.get('notes'))]
-
-        # Build the instance
-        inst = cls(
-            id        = id_,
-            type      = type_,
-            extracted = extracted,
-            #private   = private,       #TODO Has this been added?
-            person1   = person1,
-            person2   = person2,
-            facts     = facts,
-            sources   = sources,
-            notes     = notes
-        )
-
-        return inst
-
+        return Serialization.deserialize(data, Relationship)