gedcom-x 0.5.1__tar.gz → 0.5.5__tar.gz

{gedcom_x-0.5.1 → gedcom_x-0.5.5}/PKG-INFO

@@ -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.1 → gedcom_x-0.5.5}/gedcom_x.egg-info/PKG-INFO

@@ -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.1 → gedcom_x-0.5.5}/gedcom_x.egg-info/SOURCES.txt

@@ -13,12 +13,16 @@ gedcomx/Date.py
 gedcomx/Document.py
 gedcomx/Event.py
 gedcomx/EvidenceReference.py
+gedcomx/Exceptions.py
 gedcomx/Fact.py
 gedcomx/Gedcom.py
+gedcomx/Gedcom5x.py
 gedcomx/GedcomX.py
 gedcomx/Gender.py
 gedcomx/Group.py
 gedcomx/Identifier.py
+gedcomx/Logging.py
+gedcomx/Mutations.py
 gedcomx/Name.py
 gedcomx/Note.py
 gedcomx/OnlineAccount.py
@@ -27,6 +31,7 @@ gedcomx/PlaceDescription.py
 gedcomx/PlaceReference.py
 gedcomx/Qualifier.py
 gedcomx/Relationship.py
+gedcomx/Resource.py
 gedcomx/Serialization.py
 gedcomx/SourceCitation.py
 gedcomx/SourceDescription.py
@@ -34,6 +39,7 @@ gedcomx/SourceReference.py
 gedcomx/Subject.py
 gedcomx/TextValue.py
 gedcomx/TopLevelTypeCollection.py
+gedcomx/Translation.py
 gedcomx/URI.py
-gedcomx/_Resource.py
+gedcomx/Zip.py
 gedcomx/__init__.py

{gedcom_x-0.5.1 → gedcom_x-0.5.5}/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)
+
 

gedcom_x-0.5.5/gedcomx/Agent.py

@@ -0,0 +1,196 @@
+import base64
+import uuid
+
+from typing import List, Optional
+
+from .Address import Address
+#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
+        standard_uuid = uuid.uuid4()
+        # Convert UUID to bytes
+        uuid_bytes = standard_uuid.bytes
+        # Encode bytes to a Base64 string
+        short_uuid = base64.urlsafe_b64encode(uuid_bytes).rstrip(b'=').decode('utf-8')
+        return short_uuid
+    
+    def __init__(self, id: Optional[str] = None,
+                    identifiers: Optional[IdentifierList] = None, 
+                    names: Optional[List[TextValue]] = [], 
+                    homepage: Optional[URI] = None, 
+                    openid: Optional[URI] = None, 
+                    accounts: Optional[List[OnlineAccount]] = [],
+                    emails: Optional[List[URI]] = [], 
+                    phones: Optional[List[URI]] = [], 
+                    addresses: Optional[List[Address]] = [], 
+                    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 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):
+        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):
+            for current_address in self.addresses:
+                if address_to_add == current_address:
+                    return False
+            self.addresses.append(address_to_add)
+        else:
+            raise ValueError(f"address must be of type Address, not {type(address_to_add)}")
+        
+    def add_name(self, name_to_add: TextValue):
+        if isinstance(name_to_add,str): name_to_add = TextValue(value=name_to_add)
+        if name_to_add and isinstance(name_to_add,TextValue):
+            for current_name in self.names:
+                if name_to_add == current_name:
+                    return
+            self.names.append(name_to_add)
+        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):
+        type_as_dict = {
+            "id": self.id if self.id else None,
+            "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],
+            "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

gedcom_x-0.5.5/gedcomx/Attribution.py

@@ -0,0 +1,64 @@
+
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+from .Agent import Agent
+from .Resource import Resource, get_resource_as_dict
+from .Serialization import Serialization
+
+class Attribution:
+    """Attribution Information for a Genealogy, Conclusion, Subject and child classes
+
+    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'
+
+    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
+        
+    @property
+    def _as_dict_(self) -> Dict[str, Any]:
+        """
+        Serialize Attribution to a JSON-ready dict, skipping None values.
+        """
+        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':
+        """
+        Construct Attribution from a dict (as parsed from JSON).
+        Handles 'created' and 'modified' as ISO strings or epoch ms ints.
+        """
+        # contributor
+        
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        from .Serialization import Serialization
+        
+        return Serialization.deserialize(data, Attribution)

gedcom_x-0.5.5/gedcomx/Conclusion.py

@@ -0,0 +1,216 @@
+import base64
+import uuid
+import warnings
+
+from typing import List, Optional
+
+from .Attribution import Attribution
+#from .Document import Document
+from .Note import Note
+from .Qualifier import Qualifier
+from .Serialization import Serialization
+from .SourceReference import SourceReference
+from .Resource import Resource, URI
+from .Extensions.rs10.rsLink import _rsLinkList, rsLink
+
+from collections.abc import Sized
+
+class ConfidenceLevel(Qualifier):
+    High = "http://gedcomx.org/High"
+    Medium = "http://gedcomx.org/Medium"
+    Low = "http://gedcomx.org/Low"
+
+    _NAME_TO_URI = {
+        "high": High,
+        "medium": Medium,
+        "low": Low,
+    }
+
+    @classmethod
+    def _from_json_(cls, data):
+        """
+        Accepts:
+          - "High" | "Medium" | "Low"
+          - "http://gedcomx.org/High" | ".../Medium" | ".../Low"
+          - {"type": "..."} or {"value": "..."} or {"confidence": "..."} or {"level": "..."} or {"uri": "..."}
+          - existing ConfidenceLevel instance
+        Returns:
+          ConfidenceLevel instance with .value set to the canonical URI.
+        """
+        if data is None:
+            return None
+
+        if isinstance(data, cls):
+            return data
+
+        # Extract token from dicts or use the raw scalar
+        if isinstance(data, dict):
+            token = (
+                data.get("confidence")
+                or data.get("type")
+                or data.get("value")
+                or data.get("level")
+                or data.get("uri")
+            )
+        else:
+            token = data
+
+        if token is None:
+            return None
+
+        token_str = str(token).strip()
+
+        # Normalize to canonical URI
+        if token_str.lower() in cls._NAME_TO_URI:
+            uri = cls._NAME_TO_URI[token_str.lower()]
+        elif token_str in (cls.High, cls.Medium, cls.Low):
+            uri = token_str
+        else:
+            raise ValueError(f"Unknown ConfidenceLevel: {token!r}")
+
+        # Create a ConfidenceLevel instance without invoking Qualifier.__init__
+        obj = cls.__new__(cls)
+        # store the canonical URI on the instance; used by description and (optionally) serialization
+        obj.value = uri
+        return obj
+
+    @property
+    def description(self):
+        descriptions = {
+            self.High: "The contributor has a high degree of confidence that the assertion is true.",
+            self.Medium: "The contributor has a medium degree of confidence that the assertion is true.",
+            self.Low: "The contributor has a low degree of confidence that the assertion is true."
+        }
+        # Works whether the instance holds .value or (edge-case) if `self` is compared directly
+        key = getattr(self, "value", self)
+        return descriptions.get(key, "No description available.")
+
+    
+class Conclusion:
+    """
+    Represents a conclusion in the GEDCOM X conceptual model. A conclusion is a 
+    genealogical assertion about a person, relationship, or event, derived from 
+    one or more sources, with optional supporting metadata such as confidence, 
+    attribution, and notes.
+
+    Args:
+        id (str, optional): A unique identifier for the conclusion. If not provided, 
+            a UUID-based identifier will be automatically generated.
+        lang (str, optional): The language code of the conclusion. Defaults to 'en'.
+        sources (list[SourceReference], optional): A list of source references that 
+            support the conclusion.
+        analysis (Document | Resource, optional): A reference to an analysis document 
+            or resource that supports the conclusion.
+        notes (list[Note], optional): A list of notes providing additional context. 
+            Defaults to an empty list.
+        confidence (ConfidenceLevel, optional): The contributor's confidence in the 
+            conclusion (High, Medium, or Low).
+        attribution (Attribution, optional): Information about who contributed the 
+            conclusion and when.
+        uri (Resource, optional): A URI reference for the conclusion. Defaults to a 
+            URI with the fragment set to the `id`.
+        links (_LinkList, optional): A list of links associated with the conclusion. 
+            Defaults to an empty `_LinkList`.  
+    """
+    identifier = 'http://gedcomx.org/v1/Conclusion'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    @staticmethod
+    def default_id_generator():
+        # Generate a standard UUID
+        standard_uuid = uuid.uuid4()
+        # Convert UUID to bytes
+        uuid_bytes = standard_uuid.bytes
+        # Encode bytes to a Base64 string
+        short_uuid = base64.urlsafe_b64encode(uuid_bytes).rstrip(b'=').decode('utf-8')
+        return short_uuid
+    
+    def __init__(self,
+                 id: Optional[str] = None,
+                 lang: Optional[str] = 'en',
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[object | Resource] = None,
+                 notes: Optional[List[Note]] = None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 uri: Optional[Resource] = None,
+                 _max_note_count: int = 20,
+                 links: Optional[_rsLinkList] = None) -> None:
+        
+        self._id_generator = Conclusion.default_id_generator
+
+        self.id = id if id else None
+        self.lang = lang
+        self.sources = sources if sources else []
+        self.analysis = analysis
+        self.notes = notes if notes else []
+        self.confidence = confidence
+        self.attribution = attribution
+        self.max_note_count = _max_note_count
+        self.uri = uri if uri else URI(fragment=id if id else self.id)
+        self.links = links if links else _rsLinkList()    #NOTE This is not in specification, following FS format
+    
+    def add_note(self,note_to_add: Note):
+        if self.notes and len(self.notes) >= self.max_note_count:
+            warnings.warn(f"Max not count of {self.max_note_count} reached for id: {self.id}")
+            return False
+        if note_to_add and isinstance(note_to_add,Note):
+            for existing in self.notes:
+                if note_to_add == existing:
+                    return False
+            self.notes.append(note_to_add)
+
+    def add_source(self, source_to_add: SourceReference):
+        if source_to_add and isinstance(source_to_add,SourceReference):
+            for current_source in self.sources:
+                if source_to_add == current_source:
+                    return
+            self.sources.append(source_to_add)
+        else:
+            raise ValueError()
+        
+    def add_link(self,link: rsLink) -> bool:
+        """
+        Adds a link to the Conclusion link list.
+
+        Args:
+            link (rsLink): The link to be added.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        
+        Note: Duplicate checking not impimented at this level
+        """
+        if link and isinstance(link,rsLink):
+            self.links.add(link)
+            return True
+        return False
+    
+    @property
+    def _as_dict_(self):
+        type_as_dict = {
+            'id':self.id,
+            'lang':self.lang,
+            'sources': [source._as_dict_ for source in self.sources] if self.sources else None,
+            'analysis': self.analysis if self.analysis else None,
+            'notes': [note for note in self.notes] if self.notes else None,
+            'confidence':self.confidence,
+            'attribution':self.attribution,
+            'links':self.links._as_dict_ if self.links else None
+        }
+      
+        return Serialization.serialize_dict(type_as_dict) 
+    
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        
+        return (
+            self.id == other.id and
+            self.lang == other.lang and
+            self.sources == other.sources and
+            self.analysis == other.analysis and
+            self.notes == other.notes and
+            self.confidence == other.confidence and
+            self.attribution == other.attribution
+        )

{gedcom_x-0.5.1 → gedcom_x-0.5.5}/gedcomx/Coverage.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 from .Date import Date
 from .PlaceReference import PlaceReference
+from .Serialization import Serialization
 
 class Coverage:
     identifier = 'http://gedcomx.org/v1/Coverage'
@@ -13,6 +14,15 @@ class Coverage:
     
     # ...existing code...
 
+    @property
+    def _as_dict_(self):
+        type_as_dict = {
+            'spatial': self.spatial if self.spatial else None,
+            'temporal': self. temporal if self.temporal else None
+        }
+
+        return Serialization.serialize_dict(type_as_dict) 
+
     @classmethod
     def _from_json_(cls, data: dict):
         """