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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcom-x
-Version: 0.5.2
+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.2 → 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.2
+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.2 → gedcom_x-0.5.5}/gedcom_x.egg-info/SOURCES.txt

@@ -16,11 +16,13 @@ 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
@@ -37,8 +39,7 @@ gedcomx/SourceReference.py
 gedcomx/Subject.py
 gedcomx/TextValue.py
 gedcomx/TopLevelTypeCollection.py
+gedcomx/Translation.py
 gedcomx/URI.py
 gedcomx/Zip.py
-gedcomx/_Links.py
-gedcomx/__init__.py
-gedcomx/g7interop.py
+gedcomx/__init__.py

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Address.py

@@ -61,6 +61,8 @@ class Address:
     
     @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):

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Agent.py

@@ -139,6 +139,14 @@ class Agent:
         }
         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.
@@ -179,8 +187,7 @@ class Agent:
             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

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Attribution.py

@@ -10,11 +10,11 @@ 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).
+        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):            timestamp for when this record was created
+        created (timestamp, optional):            timestamp for when this record was created
 
     Raises:
         
@@ -56,45 +56,9 @@ class Attribution:
         """
         # 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
-        )
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        from .Serialization import Serialization
+        
+        return Serialization.deserialize(data, Attribution)

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

@@ -11,7 +11,7 @@ from .Qualifier import Qualifier
 from .Serialization import Serialization
 from .SourceReference import SourceReference
 from .Resource import Resource, URI
-from ._Links import _LinkList, _Link
+from .Extensions.rs10.rsLink import _rsLinkList, rsLink
 
 from collections.abc import Sized
 
@@ -19,15 +19,72 @@ 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 = {
-            ConfidenceLevel.High: "The contributor has a high degree of confidence that the assertion is true.",
-            ConfidenceLevel.Medium: "The contributor has a medium degree of confidence that the assertion is true.",
-            ConfidenceLevel.Low: "The contributor has a low degree of confidence that the assertion is true."
+            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."
         }
-        return descriptions.get(self, "No description available.")
+        # 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:
     """
@@ -53,13 +110,7 @@ class Conclusion:
         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`.
+            Defaults to an empty `_LinkList`.  
     """
     identifier = 'http://gedcomx.org/v1/Conclusion'
     version = 'http://gedcomx.org/conceptual-model/v1'
@@ -75,20 +126,20 @@ class Conclusion:
         return short_uuid
     
     def __init__(self,
-                 id: Optional[str],
+                 id: Optional[str] = None,
                  lang: Optional[str] = 'en',
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[object | Resource] = None,
-                 notes: Optional[List[Note]] = [],
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  uri: Optional[Resource] = None,
                  _max_note_count: int = 20,
-                 links: Optional[_LinkList] = None) -> None:
+                 links: Optional[_rsLinkList] = None) -> None:
         
         self._id_generator = Conclusion.default_id_generator
 
-        self.id = id if id else self._id_generator()
+        self.id = id if id else None
         self.lang = lang
         self.sources = sources if sources else []
         self.analysis = analysis
@@ -96,8 +147,8 @@ class Conclusion:
         self.confidence = confidence
         self.attribution = attribution
         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
+        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:
@@ -118,9 +169,22 @@ class Conclusion:
         else:
             raise ValueError()
         
-    def add_link(self,link: _Link):
-        if link and isinstance(link,_Link):
+    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):

{gedcom_x-0.5.2 → 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):
         """

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Date.py

@@ -21,7 +21,8 @@ class Date:
 
         self.normalized: DateNormalization | None = normalized if normalized else None
     
-    def _prop_dict(self):
+    @property
+    def _as_dict_(self):
         return {'original': self.orginal,
                 'formal': self.formal}
 
@@ -33,12 +34,6 @@ class Date:
         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):
     """

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Document.py

@@ -1,13 +1,13 @@
 from enum import Enum
 from typing import Optional, List
 
-from gedcomx.Attribution import Attribution
-#from gedcomx.Conclusion import ConfidenceLevel
-from gedcomx.Note import Note
-from gedcomx.SourceReference import SourceReference
-from gedcomx.Resource import Resource
+from .Attribution import Attribution
+from .Note import Note
+from .SourceReference import SourceReference
+from .Resource import Resource
 
 from .Conclusion import Conclusion
+from .Serialization import Serialization
 
 class DocumentType(Enum):
     Abstract = "http://gedcomx.org/Abstract"
@@ -49,4 +49,25 @@ class Document(Conclusion):
         self.type = type
         self.extracted = extracted
         self.textType = textType
-        self.text = text
+        self.text = text
+    
+    @property
+    def _as_dict(self):
+        type_as_dict = super()._as_dict_
+        if self.type:
+            type_as_dict['type'] = self.type.value
+        if self.extracted is not None:
+            type_as_dict['extracted'] = self.extracted
+        if self.textType:
+            type_as_dict['textType'] = self.textType.value
+        if self.text:
+            type_as_dict['text'] = self.text
+        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('Document')
+        return Serialization.deserialize(data, type_as_dict)

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Event.py

@@ -9,6 +9,7 @@ from .Conclusion import Conclusion, ConfidenceLevel
 from .Date import Date
 from .Note import Note
 from .PlaceReference import PlaceReference
+from .Serialization import Serialization
 from .SourceReference import SourceReference
 from .Subject import Subject
 from .Resource import Resource
@@ -84,6 +85,7 @@ class EventType(Enum):
     Naturalization = "http://gedcomx.org/Naturalization"
     Ordination = "http://gedcomx.org/Ordination"
     Retirement = "http://gedcomx.org/Retirement"
+    MarriageSettlment = 'https://gedcom.io/terms/v7/MARS'
     
     @property
     def description(self):
@@ -192,4 +194,21 @@ class Event(Subject):
                  date: Optional[Date] = None,
                  place: Optional[PlaceReference] = None,
                  roles: Optional[List[EventRole]] = []) -> None:
-        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)
+
+        self.type = type if type and isinstance(type, EventType) else None
+        self.date = date if date and isinstance(date, Date) else None               
+        self.place = place if place and isinstance(place, PlaceReference) else None
+        self.roles = roles if roles and isinstance(roles, list) else []
+    
+    @property
+    def _as_dict_(self):
+        raise NotImplementedError("Not implemented yet")
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        type_as_dict = Serialization.get_class_fields('Event')
+        return Serialization.deserialize(data, type_as_dict)

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Exceptions.py

@@ -3,6 +3,12 @@
 class GedcomXError(Exception):
     """Base for all app-specific errors."""
 
+class GedcomClassAttributeError(GedcomXError):
+    def __init__(self, *args: object) -> None:
+        msg = f"This class need more information to be created: {args}"
+        super().__init__(msg)
+
+
 class TagConversionError(GedcomXError):
     def __init__(self, record,levelstack):
         msg = f"Cannot convert: #{record.line} TAG: {record.tag} {record.xref if record.xref else ''} Value:{record.value} STACK: {type(levelstack[record.level-1]).__name__}"

{gedcom_x-0.5.2 → gedcom_x-0.5.5}/gedcomx/Fact.py

@@ -22,7 +22,7 @@ from enum import Enum
 
 from collections.abc import Sized
 
-from ._Links import _Link, _LinkList
+from .Extensions.rs10.rsLink import rsLink, _rsLinkList
 
 
 class FactType(Enum):
@@ -401,14 +401,14 @@ class Fact(Conclusion):
                  sources: Optional[List[SourceReference]] = [],
                  analysis: Optional[Resource | Document] = None,
                  notes: Optional[List[Note]] = [],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
-                 type: FactType = None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 type: Optional[FactType] = None,
                  date: Optional[Date] = None,
                  place: Optional[PlaceReference] = None,
                  value: Optional[str] = None,
                  qualifiers: Optional[List[FactQualifier]] = None,
-                 links: Optional[_LinkList] = None):
+                 links: Optional[_rsLinkList] = None):
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, links=links)
         self.type = type
         self.date = date
@@ -433,12 +433,11 @@ class Fact(Conclusion):
         # Only add Relationship-specific fields
         fact_dict.update( {
             'type': self.type.value if self.type else None,
-            'date': self.date._prop_dict() if self.date else None,
+            'date': self.date._as_dict_ if self.date else None,
             'place': self.place._as_dict_ if self.place else None,
             'value': self.value,
             'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
         })
-
         
         return Serialization.serialize_dict(fact_dict)
     
@@ -463,7 +462,7 @@ class Fact(Conclusion):
                         if data.get('place') else None)
         value        = data.get('value')
         qualifiers   = [Qualifier._from_json_(q) for q in data.get('qualifiers', [])]
-        links = _LinkList._from_json_(data.get('links')) if data.get('links') else None
+        links = _rsLinkList._from_json_(data.get('links')) if data.get('links') else None
 
         return cls(
             id=id_,

gedcom_x-0.5.5/gedcomx/Gedcom.py

@@ -0,0 +1,53 @@
+import re
+
+class Gedcom():
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def read_gedcom_version(filepath: str) -> str | None:
+        """
+        Reads only the HEAD section of a GEDCOM file and returns the GEDCOM standard version.
+        Looks specifically for HEAD → GEDC → VERS.
+        
+        Returns:
+            str: GEDCOM version (e.g., "5.5.1" or "7.0.0"), or None if not found.
+        """
+        version = None
+        inside_head = False
+        inside_gedc = False
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            for line in f:
+                parts = line.strip().split(maxsplit=2)
+                if not parts:
+                    continue
+
+                level = int(parts[0])
+                tag = parts[1] if len(parts) > 1 else ""
+                value = parts[2] if len(parts) > 2 else None
+
+                # Enter HEAD
+                if level == 0 and tag == "HEAD":
+                    inside_head = True
+                    continue
+
+                # Leave HEAD block
+                if inside_head and level == 0:
+                    break
+
+                # Inside HEAD, look for GEDC
+                if inside_head and level == 1 and tag == "GEDC":
+                    inside_gedc = True
+                    continue
+
+                # If we drop back to level 1 (but not GEDC), stop looking inside GEDC
+                if inside_gedc and level == 1:
+                    inside_gedc = False
+
+                # Inside GEDC, look for VERS
+                if inside_gedc and tag == "VERS":
+                    version = value
+                    break
+
+        return version