gedcom-x 0.5__tar.gz → 0.5.2__tar.gz

{gedcom_x-0.5 → gedcom_x-0.5.2}/PKG-INFO

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

{gedcom_x-0.5 → gedcom_x-0.5.2}/gedcom_x.egg-info/PKG-INFO

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

{gedcom_x-0.5 → gedcom_x-0.5.2}/gedcom_x.egg-info/SOURCES.txt

@@ -13,12 +13,14 @@ gedcomx/Date.py
 gedcomx/Document.py
 gedcomx/Event.py
 gedcomx/EvidenceReference.py
+gedcomx/Exceptions.py
 gedcomx/Fact.py
 gedcomx/Gedcom.py
 gedcomx/GedcomX.py
 gedcomx/Gender.py
 gedcomx/Group.py
 gedcomx/Identifier.py
+gedcomx/Logging.py
 gedcomx/Name.py
 gedcomx/Note.py
 gedcomx/OnlineAccount.py
@@ -27,6 +29,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
@@ -35,5 +38,7 @@ gedcomx/Subject.py
 gedcomx/TextValue.py
 gedcomx/TopLevelTypeCollection.py
 gedcomx/URI.py
-gedcomx/_Resource.py
-gedcomx/__init__.py
+gedcomx/Zip.py
+gedcomx/_Links.py
+gedcomx/__init__.py
+gedcomx/g7interop.py

{gedcom_x-0.5 → gedcom_x-0.5.2}/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,24 @@ 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):
+        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 +110,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 +124,6 @@ class Address:
             "street6": self.street6 if self.street6 else None
         }
 
+        return Serialization.serialize_dict(type_as_dict)
+
 

gedcom_x-0.5.2/gedcomx/Agent.py

@@ -0,0 +1,189 @@
+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)
+    
+    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
+        )
+        '''
+        print(other)
+        print(self)
+        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.2/gedcomx/Attribution.py

@@ -0,0 +1,100 @@
+
+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):            Contributor to object being attributed.
+        modified (timestamp):           timestamp for when this record was modified.
+        changeMessage (str):            Birth date (YYYY-MM-DD).
+        creator (Agent, optional):      Creator of object being attributed.
+        created (timestamp):            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
+        
+        contrib = None
+        if 'contributor' in data:
+            contrib_data = data['contributor']
+            
+            contrib = Resource(contrib_data['resource'],contrib_data['resourceId'])
+
+        # creator
+        creat = None
+        if 'creator' in data:
+            raw = data['creator']
+            if isinstance(raw, dict):
+                creat = Resource._from_json_(raw)
+            elif isinstance(raw, str):
+                creat = Resource(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
+        )

{gedcom_x-0.5 → gedcom_x-0.5.2}/gedcomx/Conclusion.py

@@ -5,10 +5,15 @@ 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 .URI import URI
+from .Resource import Resource, URI
+from ._Links import _LinkList, _Link
+
+from collections.abc import Sized
 
 class ConfidenceLevel(Qualifier):
     High = "http://gedcomx.org/High"
@@ -25,6 +30,37 @@ class ConfidenceLevel(Qualifier):
         return descriptions.get(self, "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`.
+
+    Methods:
+        add_note(note_to_add): Adds a note if it is not a duplicate and does not 
+            exceed the maximum allowed notes.
+        add_source(source_to_add): Adds a source reference if it is not already present.
+        add_link(link): Adds a link to the `_LinkList`.
+    """
     identifier = 'http://gedcomx.org/v1/Conclusion'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -41,28 +77,30 @@ class Conclusion:
     def __init__(self,
                  id: Optional[str],
                  lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[object | Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
-                 uri: Optional[URI] = None,
-                 max_note_count: int = 20) -> None:
+                 uri: Optional[Resource] = None,
+                 _max_note_count: int = 20,
+                 links: Optional[_LinkList] = None) -> None:
         
         self._id_generator = Conclusion.default_id_generator
 
         self.id = id if id else self._id_generator()
         self.lang = lang
-        self.sources = sources
+        self.sources = sources if sources else []
         self.analysis = analysis
-        self.notes = notes
+        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)
+        self.max_note_count = _max_note_count
+        self.uri = uri if uri else URI(fragment=id)
+        self.links = links if links else _LinkList()    #NOTE This is not in specification, following FS format
     
     def add_note(self,note_to_add: Note):
-        if len(self.notes) >= self.max_note_count:
+        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):
@@ -79,48 +117,25 @@ class Conclusion:
             self.sources.append(source_to_add)
         else:
             raise ValueError()
-    
-    '''
-    def _as_dict_(self):
-        return {
-            'id':self.id,
-            'lang':self.lang,
-            'sources': [source._prop_dict() for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
-            'notes':"Add notes here",
-            'confidence':self.confidence
-        }
-    '''
+        
+    def add_link(self,link: _Link):
+        if link and isinstance(link,_Link):
+            self.links.add(link)
     
     @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
-
-        # Only add Relationship-specific fields
-        conclusion_fields = {
+        type_as_dict = {
             'id':self.id,
             'lang':self.lang,
-            'sources': [source for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
+            '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
+            'confidence':self.confidence,
+            'attribution':self.attribution,
+            'links':self.links._as_dict_ if self.links else None
         }
-
-        # Serialize and exclude None values
-        for key, value in conclusion_fields.items():
-            if value is not None:
-                                conclusion_fields[key] = _serialize(value)
-        return conclusion_fields
+      
+        return Serialization.serialize_dict(type_as_dict) 
     
     def __eq__(self, other):
         if not isinstance(other, self.__class__):

gedcom_x-0.5.2/gedcomx/Date.py

@@ -0,0 +1,70 @@
+from typing import Optional
+from datetime import datetime, timezone
+from dateutil import parser
+import time
+
+
+class DateFormat:
+    def __init__(self) -> None:
+        pass
+
+class DateNormalization():
+    pass        
+
+class Date:
+    identifier = 'http://gedcomx.org/v1/Date'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, original: Optional[str],normalized: Optional[DateNormalization] = None ,formal: Optional[str | DateFormat] = None) -> None:
+        self.orginal = original
+        self.formal = formal
+
+        self.normalized: DateNormalization | None = normalized if normalized else None
+    
+    def _prop_dict(self):
+        return {'original': self.orginal,
+                'formal': self.formal}
+
+    @classmethod
+    def _from_json_(obj,data):
+        original = data.get('original',None)
+        formal = data.get('formal',None)
+        
+        return Date(original=original,formal=formal)
+        
+
+Date._to_dict_ = lambda self: {
+    'original': self.orginal,
+    'formal': self.formal}  
+
+
+
+
+def date_to_timestamp(date_str: str, assume_utc_if_naive: bool = True, print_definition: bool = True):
+    """
+    Convert a date string of various formats into a Unix timestamp.
+
+    A "timestamp" refers to an instance of time, including values for year, 
+    month, date, hour, minute, second, and timezone.
+    """
+    # Handle year ranges like "1894-1912" → pick first year
+    if "-" in date_str and date_str.count("-") == 1 and all(part.isdigit() for part in date_str.split("-")):
+        date_str = date_str.split("-")[0].strip()
+
+    # Parse date
+    dt = parser.parse(date_str)
+
+    # Ensure timezone awareness
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc if assume_utc_if_naive else datetime.now().astimezone().tzinfo)
+
+    # Normalize to UTC and compute timestamp
+    dt_utc = dt.astimezone(timezone.utc)
+    epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
+    ts = (dt_utc - epoch).total_seconds()
+
+    # Create ISO 8601 string with full date/time/timezone
+    full_timestamp_str = dt_utc.replace(microsecond=0).isoformat()
+
+    
+    return ts, full_timestamp_str