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

gedcomx/Person.py

@@ -3,38 +3,53 @@ from typing import List, Optional
 
 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
 from .Note import Note
 from .SourceReference import SourceReference
 from .Subject import Subject
-from .URI import URI
+from .Resource import Resource
+from collections.abc import Sized
+from ._Links import _LinkList
 
 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[_LinkList] = 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)
         
         # Initialize mutable attributes to empty lists if None
         self.sources = sources if sources is not None else []
@@ -51,8 +66,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,6 +94,18 @@ 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):
@@ -99,9 +125,10 @@ class Person(Subject):
         subject_fields.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 for fact in self.facts],
+            'uri': 'uri: ' + self.uri.value
                            
         })
 
@@ -110,20 +137,20 @@ class Person(Subject):
             if value is not None:
                 subject_fields[key] = _serialize(value)
 
-        return subject_fields
-    
-    
+        # 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)
+            }
+        
+        
     @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')
@@ -134,9 +161,9 @@ class Person(Subject):
         living  = data.get('extracted', False)
 
         # Complex singletons
-        analysis    = URI._from_json_(data['analysis']) if data.get('analysis') else None
+        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
+        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')
@@ -147,13 +174,14 @@ class Person(Subject):
             gender = Gender(type=GenderType(gender_json)) if gender_json else Gender(type=GenderType.Unknown)
         
         
-        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'))]
+        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(
@@ -172,7 +200,34 @@ class Person(Subject):
             gender      = gender,
             names       = names,
             facts       = facts,
-            living      = living
+            living      = living,
+            links       = links
         )
 
         return inst
+
+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)
+
+        
+
+    Raises:
+        ValueError: If `id` is not a valid UUID.
+    """
+    def __new__(cls, name: Optional[str], dob: Optional[str], dod: Optional[str]):
+        # 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=[name] if name else None)

gedcomx/PlaceDescription.py

@@ -4,13 +4,14 @@ 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"
@@ -19,21 +20,21 @@ class PlaceDescription(Subject):
     def __init__(self, id: str =None,
                  lang: str = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: URI = None, notes: Optional[List[Note]] =[],
+                 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[Identifier] = [],
+                 identifiers: List[IdentifierList] = [],
                  names: List[TextValue] = [],
                  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 +45,17 @@ class PlaceDescription(Subject):
         self.temporalDescription = temporalDescription
         self.spacialDescription = spatialDescription
 
-        
+    @property
+    def _as_dict_(self):
+        place_description_dict = super()._as_dict_
+        place_description_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.temporalDescription else None            
+        })
+        return Serialization.serialize_dict(place_description_dict)    

gedcomx/PlaceReference.py

@@ -1,21 +1,23 @@
 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], descriptionRef: Optional[Resource]) -> None:
         self.original = original
         self.descriptionRef = descriptionRef
 
     @property
     def _as_dict_(self):
-        return {
+        place_reference_dict = {
             'original': self.original,
-            'descriptionRef': self.descriptionRef._as_dict_ if self.descriptionRef else None
+            'descriptionRef': self.descriptionRef._as_dict_ if isinstance(self.descriptionRef,Resource) else Resource(target=self.descriptionRef)._as_dict_
             } 
+        return Serialization.serialize_dict(place_reference_dict)
 
 def ensure_list(val):
     if val is None:
@@ -25,7 +27,7 @@ def ensure_list(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
+    descriptionRef=Resource._from_json_(data['description']) if data.get('description') else None
 ))
 
    

gedcomx/Relationship.py

@@ -8,9 +8,9 @@ from .Fact import Fact
 from .Identifier import Identifier
 from .Note import Note
 from .Person import Person
-from .Serialization import serialize_to_dict
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 from .Subject import Subject
 
@@ -27,6 +27,16 @@ class RelationshipType(Enum):
         return descriptions.get(self, "No description available.")
     
 class Relationship(Subject):
+    """Represents a relationship between two Person(s)
+
+    Args:
+        type (RelationshipType): Type of relationship 
+        person1 (Person) = First Person in Relationship
+        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'
 
@@ -34,7 +44,7 @@ class Relationship(Subject):
              id: Optional[str] = None,
              lang: Optional[str] = None,
              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,
@@ -43,8 +53,8 @@ class Relationship(Subject):
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[List[Identifier]] = None,
              type: Optional[RelationshipType] = None,
-             person1: Optional[URI] = None,
-             person2: Optional[URI] = None,
+             person1: Optional[Person | Resource] = None,
+             person2: Optional[Person | Resource] = None,
              facts: Optional[List[Fact]] = None) -> None:
     
         # Call superclass initializer if required
@@ -68,8 +78,8 @@ class Relationship(Subject):
     def _as_dict_(self):
         return serialize_to_dict(self, {
             "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
-            "person1": self.person1._uri,
-            "person2": self.person2._uri,
+            "person1": self.person1.uri,
+            "person2": self.person2.uri,
             "facts": [fact for fact in self.facts] if self.facts else None
         })
 
@@ -92,8 +102,8 @@ class Relationship(Subject):
         private    = data.get('private', None)
 
         # Complex singletons (adjust as needed)
-        person1    = URI.from_url(data.get('person1')['resource']) if data.get('person1') else None
-        person2    = URI.from_url(data.get('person2')['resource']) if data.get('person2') else None
+        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'))]

gedcomx/Resource.py

@@ -0,0 +1,61 @@
+from typing import List, Optional
+
+from .URI import URI
+    
+class Resource:
+    """
+    Class used to track and resolve URIs and references between datastores.
+
+    Parameters
+    ----------
+    
+    Raises
+    ------
+    ValueError
+        If `id` is not a valid UUID.
+    """
+    def __init__(self,uri: Optional[URI|str] = None, id:Optional[str] = None,top_lvl_object: Optional[object] = None,target= None) -> None:
+        
+        self.resource = URI.from_url(uri.value)
+        self.Id = id
+
+        self.type = None
+        self.resolved = False
+        self.target: object = target
+        self.remote: bool | None = None    # is the resource pointed to persitent on a remote datastore?
+
+        if target:
+            self.resource = target._uri
+            self.Id = target.id
+            self.type = type(target)
+   
+    @property
+    def _as_dict_(self):
+        return {'resource':self.resource.value,
+                'resourceId':self.Id}
+
+def get_resource_as_dict(value):
+    """
+    If value is truthy:
+      - If it's already a Resource, return it.
+      - Otherwise, wrap it in Resource using (value._uri, value.id).
+    Returns None if value is falsy.
+    """
+    
+    if not value:
+        return None
+
+    if isinstance(value, Resource):
+        return value._as_dict_
+    
+    try:
+        return Resource(
+            getattr(value, "uri", None),
+            getattr(value, "id", None)
+        )._as_dict_
+    except AttributeError:
+        print('get_resource_as_dict',type(value),value)
+        print((f"value: {value} as inproper attributes"))
+        exit()
+
+    

gedcomx/Serialization.py

@@ -1,5 +1,7 @@
 from typing import Dict
 
+from collections.abc import Sized
+
 
 def _has_parent_class(obj) -> bool:
     return hasattr(obj, '__class__') and hasattr(obj.__class__, '__bases__') and len(obj.__class__.__bases__) > 0
@@ -34,4 +36,45 @@ def serialize_to_dict(obj,class_values:Dict,ignore_null=True):
     for key in empty_fields:
             del values_dict[key]
                 
-    return values_dict
+    return values_dict
+
+class Serialization:
+
+    @staticmethod
+    def serialize_dict(dict_to_serialize: dict) -> dict:
+        """
+        Iterates through the dict, serilaizing all Gedcom Types into a json compatible value
+        
+        Parameters
+        ----------
+        dict_to_serialize: dict
+            dict that has been created from any Gedcom Type Object's _as_dict_ property
+
+        Raises
+        ------
+        ValueError
+            If `id` is not a valid UUID.
+        """
+        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
+        
+        if dict_to_serialize and isinstance(dict_to_serialize,dict):
+            for key, value in dict_to_serialize.items():
+                if value is not None:
+                    dict_to_serialize[key] = _serialize(value)
+        
+            return {
+                    k: v
+                    for k, v in dict_to_serialize.items()
+                    if v is not None and not (isinstance(v, Sized) and len(v) == 0)
+                }
+        return {}

gedcomx/SourceCitation.py

@@ -17,4 +17,9 @@ class SourceCitation:
         """
         lang = data.get('lang', 'en')
         value = data.get('value')
-        return cls(lang=lang, value=value)
+        return cls(lang=lang, value=value)
+    
+    @property
+    def _as_dict_(self):
+        return {'lang':self.lang,
+                'value': self.value}