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

{gedcom_x-0.5.1.dist-info → gedcom_x-0.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcom-x
-Version: 0.5.1
+Version: 0.5.5
 Summary: Python implimentation of gedcom-x standard
 Author-email: "David J. Cartwright" <davidcartwright@hotmail.com>
 License: MIT

gedcom_x-0.5.5.dist-info/RECORD

@@ -0,0 +1,43 @@
+gedcomx/Address.py,sha256=FDBic6oQB30eKMWM7-6_YVPHaJdPhziU5LybwE5TY5Q,4855
+gedcomx/Agent.py,sha256=C-tzfqcjuU22iJ2LjoatKdCbI_i0xskpmZsuj58K6WY,8555
+gedcomx/Attribution.py,sha256=2bcl2UNsMPn10kDrA080qFRzxK-KYqZBgmPGNBZ2M4Y,2608
+gedcomx/Conclusion.py,sha256=t8n8FuWwzinFTPHp9D2Umu93-4A12I9L5fCx510mfqA,8414
+gedcomx/Coverage.py,sha256=BVlB3kWDoOP2j86j67hNJLC4LqoLwqs3N93z0ZbXYTw,1227
+gedcomx/Date.py,sha256=cv2UeyOcTHuH2CVHq9EjTnj3FR-r4_OVuPiuc8sbOPc,2130
+gedcomx/Document.py,sha256=32nWfDNVWkPK2_I0-hhcNQkrjH3ssdbtw-II3QMMelw,2957
+gedcomx/Event.py,sha256=BHhmO2UlxbkSzB5htdMRf2h-WNuJQsWfrSC8tNGQ6Mg,10375
+gedcomx/EvidenceReference.py,sha256=WXZpmcKzwb3lYQmGVf-TY2IsbNG3fIInPY1khRjtOSg,348
+gedcomx/Exceptions.py,sha256=0OdPM3euhBMgX8o61ZwPuKeN8zPuSuuDcSBFflVGFqk,587
+gedcomx/Fact.py,sha256=-Zz321xeFd93riaX4C4i7gIPwpqdArAYZDlWRoXA1Uk,24444
+gedcomx/Gedcom.py,sha256=l_BuLBynQacDtpLjhs2Afrabfiqt2Opoo_5_7myI7Z4,1709
+gedcomx/Gedcom5x.py,sha256=qkRmOI99N3SJEtxuzhL_IiICQIm5OyJwBkLEQIkNjUA,21223
+gedcomx/GedcomX.py,sha256=u95GeBQGRgyEp_wBl7y-RjPnhF8wTciH8Wlief99g_8,63258
+gedcomx/Gender.py,sha256=AV125vECC5JSgvNJRmotjDEt-A3cFzth6pcSLFwJBEE,2328
+gedcomx/Group.py,sha256=VNI_cI_-YnJ9cHzwMmHD8qwDNMe89kEocPuQ67rwStA,1606
+gedcomx/Identifier.py,sha256=MePkMgx0o2wzzSPGv4AJ6JklIWniEgl8XZSWKTLHXhs,8515
+gedcomx/Logging.py,sha256=vBDOjawVXc4tCge1laYjy6_2Ves-fnGzG0m6NnLZejE,624
+gedcomx/Mutations.py,sha256=idhQsnikCTovmNEGAhDsOe97V0L9AnFTRaufzUPm64w,6298
+gedcomx/Name.py,sha256=en_VkGjpZPP_Dbl9HSq2h2JCtLS2NMzmLvis5RdBPeM,12913
+gedcomx/Note.py,sha256=cvV4-fCZ0oh2zXfzD-YYoIM_WTox-fk2_bfl3i4CoNc,2251
+gedcomx/OnlineAccount.py,sha256=P24o98IXo_8XQoICYZPgALjdzS0q8t2l4DU3Od9KxyI,291
+gedcomx/Person.py,sha256=LyGPCZh6rZU_dE3GCJE92x1lLk41c_Edr_Po9smhPLc,7321
+gedcomx/PlaceDescription.py,sha256=TRHIkDiErHa_mlx_x8gYCF6UnQ-XgT08uSmYmFNa4u0,3255
+gedcomx/PlaceReference.py,sha256=3NyEYq0FaMI8m3l4H6-Ov-n9NUq_m751iYVxofqtv30,870
+gedcomx/Qualifier.py,sha256=mZ_GWT3gca8g9nWidlXIRTN5dEtf_rmnLHYl1jJkQYs,728
+gedcomx/Relationship.py,sha256=oyT501vR5jvWxqEYy3KvW9egD4CPL5JaAYWJmlNy9Ig,3599
+gedcomx/Resource.py,sha256=bZ2dV-OdpvmDRCppyfHJXiarIKL7-OcofwvYRnpOJW0,2324
+gedcomx/Serialization.py,sha256=ubtmrvi-nKmVUCK1XGwuLijrPMggNJe--kkCIC-87Ds,18580
+gedcomx/SourceCitation.py,sha256=aW-lEb7bT9QU49GiBjJppFMBvtisR6fhVVuXjr5y4vQ,742
+gedcomx/SourceDescription.py,sha256=zOkXo-fy-uCl_EGU8B-c6pzhlMk3nYNHn13ln1AkYk0,11914
+gedcomx/SourceReference.py,sha256=swVzZ5A0jt5yFYJNJvMnQZtb7d-2YEAQPxp2a4lEY1k,5071
+gedcomx/Subject.py,sha256=znee3SxYKk99JLP6KmZHkXs5hIOGu_jeLwxagENNfXs,3298
+gedcomx/TextValue.py,sha256=6B0wMxL0nigFNzhXZDhbTONvFGbnM2t2NcDZiZuu4Zw,1112
+gedcomx/TopLevelTypeCollection.py,sha256=nvTO6GwFwEZk9jX4fVqhy75ygsshomNb20tnlExKqyY,1495
+gedcomx/Translation.py,sha256=NWa1NtTOC_VgQ-EGwWG06zUpddRxdKFSLPP6066JFaA,12485
+gedcomx/URI.py,sha256=S2pFsu_VyKgOsRdHIj8pjnh6_tdA3OjAYiIugoEd70k,4271
+gedcomx/Zip.py,sha256=lBxcv-Vip45884EHj56wZJJ5I36Q38UuHUidDxQBoS8,14
+gedcomx/__init__.py,sha256=Et3E0lBdtrMjyposrQ0MeoaRilg0ShSDqXg0y15pPf4,1616
+gedcom_x-0.5.5.dist-info/METADATA,sha256=cTARXUhB_6HIix2ih1I9ThdwN1OYGn4gQA0jF9pKepM,633
+gedcom_x-0.5.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gedcom_x-0.5.5.dist-info/top_level.txt,sha256=smVBF4nxSU-mzCd6idtRYTbYjPICMMi8pTqewEmqF8Y,8
+gedcom_x-0.5.5.dist-info/RECORD,,

gedcomx/Address.py

@@ -1,7 +1,28 @@
 from typing import Optional
 import json
 
+from .Serialization import Serialization
+
 class Address:
+    """A GedcomX Address Data Type
+    A GedcomX Address Data Type.
+
+    Represents a postal address according to the GedcomX conceptual model.
+
+    Args:
+        value (str, optional): A complete address as a single string.
+        city (str, optional): Name of the city or town.
+        country (str, optional): Name of the country.
+        postalCode (str, optional): Postal or ZIP code.
+        stateOrProvince (str, optional): Name of the state, province, or region.
+        street (str, optional): First street address line.
+        street2 (str, optional): Second street address line.
+        street3 (str, optional): Third street address line.
+        street4 (str, optional): Fourth street address line.
+        street5 (str, optional): Fifth street address line.
+        street6 (str, optional): Sixth street address line.
+    """
+
     identifier = "http://gedcomx.org/v1/Address"
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -30,17 +51,26 @@ class Address:
         self.street6 = street6
 
     @property
-    def value(self) -> Optional[str]:
-        if self._value:
-            return self._value
+    def value(self) -> str: 
         return ', '.join(filter(None, [
-            self._street, self._street2, self._street3,
-            self._street4, self._street5, self._street6,
-            self._city, self._stateOrProvince,
-            self._postalCode, self._country
+            self.street, self.street2, self.street3,
+            self.street4, self.street5, self.street6,
+            self.city, self.stateOrProvince,
+            self.postalCode, self.country
         ]))
     
-         
+    @value.setter
+    def value(self,value: str):
+        self._value = value
+        return
+        raise NotImplementedError("Parsing of a full address is not implimented.")
+    
+    def _append(self,value):
+        if self._value:
+            self._value = self._value + ' ' + value
+        else:
+            self._value = value
+             
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
@@ -82,9 +112,8 @@ class Address:
         return ', '.join(filtered_parts)
     
     @property
-    def __as_dict__(self):
-        return {
-            #"value": self._value if self._value else None,
+    def _as_dict_(self):
+        type_as_dict =  {
             "city": self.city if self.city else None,
             "country": self.country if self.country else None,
             "postalCode": self.postalCode if self.postalCode else None,
@@ -97,4 +126,6 @@ class Address:
             "street6": self.street6 if self.street6 else None
         }
 
+        return Serialization.serialize_dict(type_as_dict)
+
 

gedcomx/Agent.py

@@ -4,12 +4,49 @@ import uuid
 from typing import List, Optional
 
 from .Address import Address
-from .Identifier import Identifier
+#from .Attribution import Attribution
+from .Identifier import Identifier, IdentifierList
+
 from .OnlineAccount import OnlineAccount
 from .TextValue import TextValue
+from .Resource import Resource
 from .URI import URI
+from .Serialization import Serialization
+
 
 class Agent:
+    """A GedcomX Agent Data Type.
+
+    Represents an agent entity such as a person, organization, or software 
+    responsible for creating or modifying genealogical data, as defined in 
+    the GedcomX conceptual model.
+
+    Static Methods:
+        default_id_generator(): Generates a short, URL-safe Base64-encoded UUID 
+            for use as a default agent identifier.
+
+    Args:
+        id (str, optional): A unique identifier for this agent. If not provided, 
+            one may be generated automatically using `default_id_generator()`.
+        identifiers (IdentifierList, optional): A list of alternate identifiers for this agent.
+        names (List[TextValue], optional): Names associated with the agent. Defaults to an empty list.
+        homepage (URI, optional): A link to the agent's homepage or primary website.
+        openid (URI, optional): The OpenID identifier for the agent.
+        accounts (List[OnlineAccount], optional): Online accounts associated with the agent.
+            Defaults to an empty list.
+        emails (List[URI], optional): Email addresses associated with the agent.
+            Defaults to an empty list.
+        phones (List[Resource], optional): Phone numbers associated with the agent.
+            Defaults to an empty list.
+        addresses (List[Address], optional): Postal addresses associated with the agent.
+            Defaults to an empty list.
+        person (Person, optional): A reference to the person represented 
+            by the agent. Accepts a `Person` object or a `Resource` reference. 
+            Declared as `object` to avoid circular imports.
+        attribution (Attribution, optional): Attribution information related to the agent.
+        uri (Resource, optional): A URI reference for this agent.
+    """
+    
     @staticmethod
     def default_id_generator():
         # Generate a standard UUID
@@ -21,7 +58,7 @@ class Agent:
         return short_uuid
     
     def __init__(self, id: Optional[str] = None,
-                    identifiers: Optional[List[Identifier]] = [], 
+                    identifiers: Optional[IdentifierList] = None, 
                     names: Optional[List[TextValue]] = [], 
                     homepage: Optional[URI] = None, 
                     openid: Optional[URI] = None, 
@@ -29,25 +66,33 @@ class Agent:
                     emails: Optional[List[URI]] = [], 
                     phones: Optional[List[URI]] = [], 
                     addresses: Optional[List[Address]] = [], 
-                    person: Optional[object] | Optional[URI] = None, # should be of Type 'Person', 'object' to avoid circular imports
-                    uri: URI = None): 
+                    person: Optional[object] | Optional[Resource] = None, # should be of Type 'Person', 'object' to avoid circular imports
+                    #xnotes: Optional[List[Note]] = None,
+                    attribution: Optional[object] = None, # Added for compatibility with GEDCOM5/7 Imports
+                    uri: Optional[URI | Resource] = None): 
         
         self._id_generator = Agent.default_id_generator
 
-        self.id = id if id else self._id_generator()
-        self.identifiers = identifiers
-        self.names = names
-        self.homepage = homepage
-        self.openid = openid
-        self.accounts = accounts
-        self.emails = emails
-        self.phones = phones
-        self.addresses = addresses
-        
-        self._uri = URI(fragment="agent:"+ self.id)
-    
+        self.id = id if id else None #TODO self._id_generator()
+        self.identifiers = identifiers or IdentifierList()
+        self.names = names if names else []
+        self.homepage = homepage or None
+        self.openid = openid or None
+        self.accounts = accounts or []
+        self.emails = emails or []
+        self.phones = phones or []
+        self.addresses = addresses if addresses else []
+        self.xnotes = []
+        self.attribution = attribution or None
+        self.uri = URI(fragment=self.id)
+  
     def _append_to_name(self, text_to_append: str):
-        self.names[0].value = self.names[0].value + text_to_append
+        if self.names and self.names[0] and self.names[0].value:
+            self.names[0].value = self.names[0].value + text_to_append
+        elif self.names and self.names[0]:
+            self.names[0].value = text_to_append
+        else:
+            raise ValueError() #TODO
 
     def add_address(self, address_to_add: Address):
         if address_to_add and isinstance(address_to_add, Address):
@@ -68,16 +113,84 @@ class Agent:
         else:
             raise ValueError(f'name must be of type str or TextValue, recived {type(name_to_add)}')
     
+    def add_note(self, note_to_add: 'Note'):
+        from .Note import Note
+        if note_to_add and isinstance(note_to_add,Note):
+            self.xnotes.append(note_to_add)
+        else:
+            raise ValueError(f'note must be of type Note, recived {type(note_to_add)}')
+    
+    def add_identifier(self, identifier_to_add: Identifier):
+        self.identifiers.append(identifier_to_add)
+    
     @property
-    def __as_dict__(self):
-        return {
+    def _as_dict_(self):
+        type_as_dict = {
             "id": self.id if self.id else None,
-            "identifiers": [identifier.__as_dict__() for identifier in self.identifiers],
-            "names": [name._prop_dict() for name in self.names],
+            "identifiers": self.identifiers._as_dict_ if self.identifiers else None,
+            "names": [name._as_dict_ for name in self.names],
             "homepage": self.homepage if self.homepage else None,
             "openid": self.openid if self.openid else None,
             "accounts": self.accounts if self.accounts else None,
             "emails": self.emails if self.emails else None,
             "phones": self.phones if self.phones else None,
-            "addresses": [address.__as_dict__ for address in self.addresses]
-        }
+            "addresses": [address._as_dict_ for address in self.addresses],
+            "notes": [note._as_dict_ for note in self.xnotes]
+        }
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        type_as_dict = Serialization.get_class_fields('Agent')
+        return Serialization.deserialize(data, type_as_dict)
+    
+    def __str__(self):
+        """
+        Return a human-readable string representation of the Agent.
+
+        Returns:
+            str: A concise description including ID, primary name (if any), and type of agent.
+        """
+        primary_name = self.names[0].value if self.names else "Unnamed Agent"
+        homepage_str = f", homepage={self.homepage}" if self.homepage else ""
+        return f"Agent(id={self.id}, name='{primary_name}'{homepage_str})"
+
+    def __eq__(self, other):
+        """
+        Determine equality between two Agent instances.
+
+        Args:
+            other (Agent): The other object to compare against.
+
+        Returns:
+            bool: True if both objects represent the same agent, False otherwise.
+        """
+        '''
+        if not isinstance(other, Agent):
+            return NotImplemented
+        
+        return (
+            self.id == other.id and
+            self.identifiers == other.identifiers and
+            self.names == other.names and
+            self.homepage == other.homepage and
+            self.openid == other.openid and
+            self.accounts == other.accounts and
+            self.emails == other.emails and
+            self.phones == other.phones and
+            self.addresses == other.addresses and
+            self.person == other.person and
+            self.attribution == other.attribution and
+            self.uri == other.uri
+        )
+        '''
+        
+        self_names = {n.value for n in self.names if hasattr(n, "value")}
+        other_names = {n.value for n in other.names if hasattr(n, "value")}
+        if self_names & other_names:  # intersection not empty
+            return True
+
+        return False

gedcomx/Attribution.py

@@ -1,67 +1,52 @@
+
 from datetime import datetime
 from typing import Optional, Dict, Any
 
-from .URI import URI
+from .Agent import Agent
+from .Resource import Resource, get_resource_as_dict
+from .Serialization import Serialization
 
 class Attribution:
-    identifier = 'http://gedcomx.org/v1/Attribution'
-    version = 'http://gedcomx.org/conceptual-model/v1'
+    """Attribution Information for a Genealogy, Conclusion, Subject and child classes
 
-    def __init__(self,contributor: Optional[URI],
-                 modified: Optional[datetime],
-                 changeMessage: Optional[str],
-                 creator: Optional[URI],
-                 created: Optional[datetime]) -> None:
+    Args:
+        contributor (Agent, optional):            Contributor to object being attributed.
+        modified (timestamp, optional):           timestamp for when this record was modified.
+        changeMessage (str, optional):            Birth date (YYYY-MM-DD).
+        creator (Agent, optional):      Creator of object being attributed.
+        created (timestamp, optional):            timestamp for when this record was created
+
+    Raises:
         
+    """
+    identifier = 'http://gedcomx.org/v1/Attribution'
+    version = 'http://gedcomx.org/conceptual-model/v1'
 
-        from .Agent import Agent
-        self._contributor_object = None
+    def __init__(self,contributor: Optional[Agent | Resource] = None,
+                 modified: Optional[datetime] = None,
+                 changeMessage: Optional[str] = None,
+                 creator: Optional[Agent | Resource] = None,
+                 created: Optional[datetime] = None) -> None:
+               
+        self.contributor = contributor
         self.modified = modified
         self.changeMessage = changeMessage
         self.creator = creator
         self.created = created
-
-
-        if isinstance(contributor,URI):
-            # TODO DEAL WITH URI <------------------------------------------------------------------------------------------------------------------
-            self._contributor_object = contributor
-        elif isinstance(contributor,Agent):
-            self._contributor_object = contributor
-            if hasattr(contributor,'_uri'):
-                self.contributor = contributor._uri
-            else:
-                assert False
-                self.description = URI(object=description)
-                description._uri = self.description
-                description._object = description
-        else:
-            raise ValueError(f"'description' must be of type 'SourceDescription' or 'URI', type: {type(contributor)} was provided, with value: {contributor}")
-    
+        
     @property
     def _as_dict_(self) -> Dict[str, Any]:
         """
         Serialize Attribution to a JSON-ready dict, skipping None values.
         """
-        def _fmt_dt(dt: datetime) -> str:
-            # ISO 8601 format
-            return dt.isoformat()
-
-        data: Dict[str, Any] = {}
-        if self._contributor_object:
-            data['contributor'] = (self._contributor_object._as_dict_
-                                   if hasattr(self._contributor_object, '_as_dict_') else
-                                   None)
-        if self.created:
-            data['created'] = _fmt_dt(self.created)
-        if self.creator:
-            data['creator'] = (self.creator._prop_dict()
-                                if hasattr(self.creator, '_prop_dict') else
-                                self.creator._prop_dict())
-        if self.modified:
-            data['modified'] = _fmt_dt(self.modified)
-        if self.changeMessage is not None:
-            data['changeMessage'] = self.changeMessage    
-        return data
+        type_as_dict: Dict[str, Any] = {}
+        type_as_dict['contributor'] = get_resource_as_dict(self.contributor)       
+        type_as_dict['modified'] = self.modified if self.modified else None
+        type_as_dict['changeMessage'] = self.changeMessage if self.changeMessage else None 
+        type_as_dict['creator'] = get_resource_as_dict(self.creator)         
+        type_as_dict['created'] = self.created if self.created else None
+                    
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'Attribution':
@@ -70,47 +55,10 @@ class Attribution:
         Handles 'created' and 'modified' as ISO strings or epoch ms ints.
         """
         # contributor
-        contrib = None
-        if 'contributor' in data:
-            raw = data['contributor']
-            if isinstance(raw, dict):
-                contrib = URI._from_json_(raw)
-            elif isinstance(raw, str):
-                contrib = URI(uri=raw)
-
-        # creator
-        creat = None
-        if 'creator' in data:
-            raw = data['creator']
-            if isinstance(raw, dict):
-                creat = URI._from_json_(raw)
-            elif isinstance(raw, str):
-                creat = URI(uri=raw)
-
-        # parse created date
-        raw_created = data.get('created')
-        if isinstance(raw_created, (int, float)):
-            created_dt = datetime.fromtimestamp(raw_created / 1000.0)
-        elif isinstance(raw_created, str):
-            created_dt = datetime.fromisoformat(raw_created)
-        else:
-            created_dt = None
-
-        # parse modified date
-        raw_modified = data.get('modified')
-        if isinstance(raw_modified, (int, float)):
-            modified_dt = datetime.fromtimestamp(raw_modified / 1000.0)
-        elif isinstance(raw_modified, str):
-            modified_dt = datetime.fromisoformat(raw_modified)
-        else:
-            modified_dt = None
-
-        change_msg = data.get('changeMessage')
-
-        return cls(
-            contributor=contrib,
-            created=created_dt,
-            creator=creat,
-            modified=modified_dt,
-            changeMessage=change_msg
-        )
+        
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        from .Serialization import Serialization
+        
+        return Serialization.deserialize(data, Attribution)