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

gedcomx/Name.py

@@ -1,12 +1,14 @@
 from enum import Enum
 from typing import List,Optional
+from typing_extensions import Self
 
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
 from .Date import Date
 from .Note import Note
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 
 class NameType(Enum):
@@ -99,10 +101,11 @@ class NamePart:
         self.value = value
         self.qualifiers = qualifiers
     
-    def _prop_dict(self):
-        return {'type': self.type.value if self.type else None,
-                'value': self.value if self.value else None,
-                'qualifiers': [qualifier.value for qualifier in self.qualifiers]}
+    def _as_dict_(self):
+        return Serialization.serialize_dict(
+            {'type': self.type.value if self.type else None,
+             'value': self.value if self.value else None,
+             'qualifiers': [qualifier.value for qualifier in self.qualifiers] if self.qualifiers else None})
 
     def __eq__(self, other):
         if not isinstance(other, NamePart):
@@ -120,10 +123,12 @@ class NameForm:
         self.fullText = fullText
         self.parts = parts
     
-    def _prop_dict(self):
-        return {'lang': self.lang,
-                'fullText': self.fullText,
-                'parts': [part._prop_dict() for part in self.parts]}
+    @property
+    def _as_dict_(self):
+        return Serialization.serialize_dict(
+            {'lang': self.lang,
+             'fullText': self.fullText,
+             'parts': [part._as_dict_() for part in self.parts] if self.parts else None})
     
     def _fulltext_parts(self):
         pass
@@ -137,37 +142,40 @@ class Name(Conclusion):
         """
         Takes a string and returns a GedcomX Name Object
         """
-        text = text.replace("/","")
-        parts = text.rsplit(' ', 1)
-    
-        # Assign val1 and val2 based on the split
-        given = parts[0] if len(parts) > 1 else ""
-        surname = parts[1] if len(parts) > 1 else parts[0]
+        if text:
+            text = text.replace("/","")
+            parts = text.rsplit(' ', 1)
         
-        # Remove any '/' characters from both val1 and val2
-        #given = given.replace('/', '')
-        #surname = surname.replace('/', '')
+            # Assign val1 and val2 based on the split
+            given = parts[0] if len(parts) > 1 else ""
+            surname = parts[1] if len(parts) > 1 else parts[0]
+            
+            # Remove any '/' characters from both val1 and val2
+            #given = given.replace('/', '')
+            #surname = surname.replace('/', '')
 
-        given_name_part = NamePart(type = NamePartType.Given, value=given)
-        surname_part = NamePart(type = NamePartType.Surname, value=surname)
+            given_name_part = NamePart(type = NamePartType.Given, value=given)
+            surname_part = NamePart(type = NamePartType.Surname, value=surname)
 
-        name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
-        name = Name(type=NameType.BirthName,nameForms=[name_form])
+            name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
+            name = Name(type=NameType.BirthName,nameForms=[name_form])
+        else:
+            name = Name()
         return name
 
     def __init__(self, id: str = None,
                  lang: str = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: URI = None,
-                 notes: Optional[List[Note]] = [],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Resource = None,
+                 notes: Optional[List[Note]] = None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
                  type: Optional[NameType] = None,
-                 nameForms: NameForm = [],
+                 nameForms: Optional[List[NameForm]]= None,
                  date: Optional[Date] = None) -> None:
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
         self.type = type
-        self.nameForms = nameForms
+        self.nameForms = nameForms if nameForms else []
         self.date = date
     
     def _add_name_part(self, namepart_to_add: NamePart):
@@ -179,13 +187,45 @@ class Name(Conclusion):
     
     @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
+            
         name_as_dict = super()._as_dict_
+
         name_as_dict.update( {
             'type':self.type.value if self.type else None,
-            'nameForms': [nameForm._prop_dict() for nameForm in self.nameForms],
-            'date': self.date._prop_date() if self.date else None})
+            'nameForms': [nameForm._as_dict_ for nameForm in self.nameForms],
+            'date': self.date._as_dict_ if self.date else None})
+        
+        #del name_as_dict['id']
+        # Serialize and exclude None values
+        for key, value in name_as_dict.items():
+            if value is not None:
+                name_as_dict[key] = _serialize(value)
+
+        # 3) merge and filter out None *at the top level*
+        return {
+            k: v
+            for k, v in name_as_dict.items()
+            if v is not None
+        }
+    
         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 []
@@ -223,7 +263,7 @@ Name._from_json_ = classmethod(lambda cls, data: cls(
     id=data.get('id'),
     lang=data.get('lang', 'en'),
     sources=[SourceReference._from_json_(s) for s in ensure_list(data.get('sources'))],
-    analysis=URI._from_json_(data['analysis']) if data.get('analysis') else None,
+    analysis=Resource._from_json_(data['analysis']) if data.get('analysis') else None,
     notes=[Note._from_json_(n) for n in ensure_list(data.get('notes'))],
     confidence=ConfidenceLevel._from_json_(data['confidence']) if data.get('confidence') else None,
     attribution=Attribution._from_json_(data['attribution']) if data.get('attribution') else None,
@@ -232,10 +272,5 @@ Name._from_json_ = classmethod(lambda cls, data: cls(
     date=Date._from_json_(data['date']) if data.get('date') else None
 ))
 
-Name._to_dict_ = lambda self: {
-    **self._as_dict_,
-    'type': self.type.value if self.type else None,
-    'nameForms': [nf._to_dict_() for nf in self.nameForms] if self.nameForms else [],
-    'date': self.date._prop_date() if self.date else None
-}
+
 

gedcomx/Note.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from .Attribution import Attribution
+from .Serialization import Serialization
 
 class Note:
     identifier = 'http://gedcomx.org/v1/Note'
@@ -10,24 +11,24 @@ class Note:
         self.lang = lang
         self.subject = subject
         self.text = text
-        self.attribution = attribution
-    
-    
+        self.attribution = attribution  
 
     def append(self, text_to_add: str):
         if text_to_add and isinstance(text_to_add, str):
             self.text = self.text + text_to_add
         else:
+            return #TODO
             raise ValueError("The text to add must be a non-empty string.")
     
     @property
     def _as_dict_(self):
-        return {
+        note_dict = {
             "lang":self.lang if self.lang else None,
             "subject":self.subject if self.subject else None,
             "text":self.text if self.text else None,
             "attribution": self.attribution if self.attribution else None
         }
+        return Serialization.serialize_dict(note_dict)
     
     def __eq__(self, other):
         if not isinstance(other, Note):

gedcomx/OnlineAccount.py

@@ -1,10 +1,10 @@
 from typing import Optional
 
-from .URI import URI
+from .Resource import Resource
 
 class OnlineAccount:
     identifier = 'http://gedcomx.org/v1/OnlineAccount'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, serviceHomepage: URI, accountName: str) -> None:
+    def __init__(self, serviceHomepage: Resource, accountName: str) -> None:
         pass

gedcomx/Person.py

@@ -1,40 +1,58 @@
 from enum import Enum
 from typing import List, Optional
+from urllib.parse import urljoin
 
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
+from .Date import Date
 from .EvidenceReference import EvidenceReference
-from .Fact import Fact
+from .Fact import Fact, FactType
 from .Gender import Gender, GenderType
-from .Identifier import Identifier
-from .Name import Name, NameForm, NamePart, NamePartType, NamePartQualifier
+from .Identifier import IdentifierList
+from .Name import Name, QuickName
 from .Note import Note
 from .SourceReference import SourceReference
+from .Serialization import Serialization
 from .Subject import Subject
-from .URI import URI
+from .Resource import Resource
+from collections.abc import Sized
+from .Extensions.rs10.rsLink import _rsLinkList
 
 class Person(Subject):
+    """A person in the system.
+
+    Args:
+        id (str):      Unique identifier for this person.
+        name (str):    Full name.
+        birth (date):  Birth date (YYYY-MM-DD).
+        friends (List[Person], optional): List of friends. Defaults to None.
+
+    Raises:
+        ValueError: If `id` is not a valid UUID.
+    """
     identifier = 'http://gedcomx.org/v1/Person'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str = None,
+    def __init__(self, id: str | None = None,
              lang: str = 'en',
              sources: Optional[List[SourceReference]] = None,
-             analysis: Optional[URI] = None,
+             analysis: Optional[Resource] = None,
              notes: Optional[List[Note]] = None,
              confidence: Optional[ConfidenceLevel] = None,
              attribution: Optional[Attribution] = None,
              extracted: bool = None,
              evidence: Optional[List[EvidenceReference]] = None,
              media: Optional[List[SourceReference]] = None,
-             identifiers: Optional[List[Identifier]] = None,
+             identifiers: Optional[IdentifierList] = None,
              private: Optional[bool] = False,
              gender: Optional[Gender] = Gender(type=GenderType.Unknown),
              names: Optional[List[Name]] = None,
              facts: Optional[List[Fact]] = None,
-             living: Optional[bool] = False) -> None:
+             living: Optional[bool] = False,
+             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)
+        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 []
@@ -51,8 +69,7 @@ class Person(Subject):
         self.living = living       #TODO This is from familysearch API
 
         self._relationships = []
-        
-    
+          
     def add_fact(self, fact_to_add: Fact) -> bool:
         if fact_to_add and isinstance(fact_to_add,Fact):
             for current_fact in self.facts:
@@ -80,99 +97,96 @@ class Person(Subject):
         else:
             raise ValueError()
     
+    def display(self):
+        display = {
+        "ascendancyNumber": "1",
+        "deathDate": "from 2001 to 2005",
+        "descendancyNumber": "1",
+        "gender": self.gender.type,
+        "lifespan": "-2005",
+        "name": self.names[0].nameForms[0].fullText
+            }
+        
+        return display
+
     @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.type.value if self.gender.type else None,
-            'names': [name for name in self.names],
-            'facts': [fact for fact in self.facts]
+            'gender': self.gender._as_dict_ if self.gender else None,
+            'names': [name._as_dict_ for name in self.names],
+            '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)
-
-        return subject_fields
-    
-    
+        return Serialization.serialize_dict(type_as_dict)
+           
     @classmethod
     def _from_json_(cls, data: dict):
         """
         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
-        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    = URI._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)
+        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.
+
+    Underlying GedcomX Types are created for you.
         
+    Args:
+        name (str):    Full name.
+        birth (date,Optional):  Birth date (YYYY-MM-DD).
+        death (date, Optional)
+
         
-        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'))]
-        evidence    = [EvidenceReference._from_json_(o) for o in ensure_list(data.get('evidence'))]
-        media       = [SourceReference._from_json_(o)   for o in ensure_list(data.get('media'))]
-        identifiers = [Identifier._from_json_(o)        for o in ensure_list(data.get('identifiers'))]
-        names       = [Name._from_json_(o)              for o in ensure_list(data.get('names'))]
-        facts       = [Fact._from_json_(o)              for o in ensure_list(data.get('facts'))]
-
-        # 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
-        )
-
-        return inst
+
+    Raises:
+        ValueError: If `id` is not a valid UUID.
+    """
+    def __new__(cls, name: str, dob: Optional[str] = None, dod: Optional[str] = None):
+        # Build facts from args
+        facts = []
+        if dob:
+            facts.append(Fact(type=FactType.Birth, date=Date(original=dob)))
+        if dod:
+            facts.append(Fact(type=FactType.Death, date=Date(original=dod)))
+
+        # Return the different class instance
+        return Person(facts=facts, names=[QuickName(name=name)] if name else None)

gedcomx/PlaceDescription.py

@@ -4,36 +4,39 @@ from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
 from .Date import Date
 from .EvidenceReference import EvidenceReference
-from .Identifier import Identifier
+from .Identifier import IdentifierList
 from .Note import Note
 from .SourceReference import SourceReference
 from .TextValue import TextValue
-from .URI import URI
-
+from .Resource import Resource
+from .Serialization import Serialization
 from .Subject import Subject
+from .URI import URI
 
 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: URI = None, notes: Optional[List[Note]] =[],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
-                 extracted: bool = None,
-                 evidence: List[EvidenceReference] = None,
-                 media: List[SourceReference] = [],
-                 identifiers: List[Identifier] = [],
-                 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["PlaceDescription"] = None, # PlaceDescription
+                 jurisdiction: Optional["Resource | PlaceDescription"] = None, # PlaceDescription
                  latitude: Optional[float] = None,
                  longitude: Optional[float] = None,
                  temporalDescription: Optional[Date] = None,
-                 spatialDescription: Optional[URI] = None,) -> 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
@@ -44,4 +47,24 @@ class PlaceDescription(Subject):
         self.temporalDescription = temporalDescription
         self.spacialDescription = spatialDescription
 
-        
+    @property
+    def _as_dict_(self):
+        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,
+            "jurisdiction": self.jurisdiction._as_dict_ if self.jurisdiction else None,
+            "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.spacialDescription else None            
+        })
+        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

@@ -1,31 +1,30 @@
 from typing import Optional
 
-from .URI import URI
+from .Resource import Resource
+from .Serialization import Serialization
 
 class PlaceReference:
     identifier = 'http://gedcomx.org/v1/PlaceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
     
-    def __init__(self, original: Optional[str], descriptionRef: Optional[URI]) -> 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):
-        return {
+        type_as_dict = {
             'original': self.original,
-            'descriptionRef': self.descriptionRef._as_dict_ if self.descriptionRef else None
+            'description': self.description._as_dict_ if self.description else None
             } 
+        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=URI._from_json_(data['description']) if data.get('description') else None
-))
 
-