gedcom-x 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

gedcomx/{Mutations.py → mutations.py}

@@ -1,6 +1,37 @@
-from .Gedcom5x import Gedcom5xRecord
-from .Fact import Fact, FactType
-from .Event import Event, EventType
+
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    mutations.py
+ Author:  David J. Cartwright
+ Purpose: Objects used to convert TAGs/Structues/Types from GEDCOM Versions
+    when simple parsing will not work. (complex or ambiguous structures)
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: cleaned up imports and documentation
+   - 2025-09-01: filename PEP8 standard, imports changed accordingly
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .gedcom5x import Gedcom5xRecord
+from .fact import Fact, FactType
+from .event import Event, EventType
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 fact_event_table = {
     # Person Fact / Event Types
@@ -178,33 +209,34 @@ fact_event_table = {
 }
 
 class GedcomXObject:
-    def __init__(self,record: Gedcom5xRecord | None = None) -> None:
-        self.created_with_tag: str = record.tag if record and isinstance(record, Gedcom5xRecord) else None    
-        self.created_at_level: int = record.level if record and isinstance(record, Gedcom5xRecord) else None
-        self.created_at_line_number: int = record.line_number if record and isinstance(record, Gedcom5xRecord) else None
+    def __init__(self,record: Gedcom5xRecord) -> None:
+        self.record = record
+        self.created_with_tag: str | None = record.tag if record and isinstance(record, Gedcom5xRecord) else None    
+        self.created_at_level: int | None = record.level if record and isinstance(record, Gedcom5xRecord) else None
+        self.created_at_line_number: int | None = record.line if record and isinstance(record, Gedcom5xRecord) else None
 
 class GedcomXSourceOrDocument(GedcomXObject):
-    def __init__(self,record: Gedcom5xRecord | None = None) -> None:
+    def __init__(self,record: Gedcom5xRecord) -> None:
         super().__init__(record)
-        self.title: str = None
-        self.citation: str = None
-        self.page: str = None
-        self.contributor: str = None
-        self.publisher: str = None
-        self.rights: str = None
-        self.url: str = None
-        self.medium: str = None
-        self.type: str = None
-        self.format: str = None
-        self.created: str = None
-        self.modified: str = None
-        self.language: str = None
-        self.relation: str = None
-        self.identifier: str = None
-        self.description: str = None
+        self.title: str | None = None
+        self.citation: str | None = None
+        self.page: str | None = None
+        self.contributor: str | None = None
+        self.publisher: str | None = None
+        self.rights: str | None = None
+        self.url: str | None = None
+        self.medium: str | None = None
+        self.type: str | None = None
+        self.format: str | None = None
+        self.created: str | None = None
+        self.modified: str | None = None
+        self.language: str | None = None
+        self.relation: str | None = None
+        self.identifier: str | None = None
+        self.description: str | None = None
 
 class GedcomXEventOrFact(GedcomXObject):
-    def __new__(cls,record: Gedcom5xRecord | None = None, object_stack: dict | None = None) -> object:
+    def __new__(cls,record: Gedcom5xRecord, object_stack: dict | None = None) -> object:
         super().__init__(record)
         if record.tag in fact_event_table.keys():
 
@@ -219,10 +251,7 @@ class GedcomXEventOrFact(GedcomXObject):
             raise ValueError(f"{record.tag} not found in map")
 
 class GedcomXRelationshipBuilder(GedcomXObject):
-    def __new__(cls,record: Gedcom5xRecord | None = None, object_stack: dict | None = None) -> object:
-        last_relationship = object_stack.get('lastrelationship',None)
-        last_relationship_data = object_stack.get('lastrelationshipdata',None)
-        if not isinstance(last_relationship_data,dict):
-            last_relationship_data = None
+    def __init__(self, record: Gedcom5xRecord) -> None:
+        super().__init__(record)
 
         

gedcomx/{Name.py → name.py}

@@ -1,6 +1,5 @@
 from enum import Enum
 from typing import List,Optional
-from typing_extensions import Self
 
 """
 ======================================================================
@@ -12,6 +11,7 @@ from typing_extensions import Self
  Created: 2025-08-25
  Updated:
    - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   - 2025-09-03: _from_json_ refactor
    
 ======================================================================
 """
@@ -22,13 +22,23 @@ GEDCOM Module Types
 ======================================================================
 """
 #======================================================================
-from .Attribution import Attribution
-from .Conclusion import Conclusion, ConfidenceLevel
-from .Date import Date
-from .Note import Note
-from .Resource import Resource
-from .SourceReference import SourceReference
-#======================================================================
+from .attribution import Attribution
+from .conclusion import Conclusion, ConfidenceLevel
+from .date import Date
+from .document import Document
+from .Extensions.rs10.rsLink import _rsLinks
+from .note import Note
+from .resource import Resource
+from .source_reference import SourceReference
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 
 class NameType(Enum):
@@ -39,6 +49,7 @@ class NameType(Enum):
     AdoptiveName = "http://gedcomx.org/AdoptiveName"
     FormalName = "http://gedcomx.org/FormalName"
     ReligiousName = "http://gedcomx.org/ReligiousName"
+    Other = "other"
     
     @property
     def description(self):
@@ -145,7 +156,7 @@ class NamePart:
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         type_as_dict = {}
         if self.type:
             type_as_dict['type'] = self.type.value
@@ -153,14 +164,28 @@ class NamePart:
             type_as_dict['value'] = self.value
         if self.qualifiers:
             type_as_dict['qualifiers'] = [q.value for q in self.qualifiers]
-        Serialization.serialize_dict(type_as_dict)
+        return type_as_dict if type_as_dict != {} else None
     
     @classmethod
-    def _from_json_(cls,data):
-        name_part =NamePart(type=NamePartType(data['type']) if 'type' in data else None,
-                            value=data.get('value'),
-                            qualifiers=[NamePartQualifier(q) for q in data.get('qualifiers')])
-        return name_part
+    def _from_json_(cls, data: dict, context=None) -> "NamePart":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict, got {type(data)}")
+
+        name_part = {}
+
+        # Enum / type
+        if (typ := data.get("type")) is not None:
+            name_part["type"] = NamePartType(typ)
+
+        # String value
+        if (val := data.get("value")) is not None:
+            name_part["value"] = val
+
+        # List of qualifiers
+        if (quals := data.get("qualifiers")) is not None:
+            name_part["qualifiers"] = [NamePartQualifier(q) for q in quals]
+
+        return cls(**name_part)
 
     def __eq__(self, other):
         if not isinstance(other, NamePart):
@@ -226,24 +251,36 @@ class NameForm:
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         type_as_dict = {}
         if self.lang:
             type_as_dict['lang'] = self.lang
         if self.fullText:
             type_as_dict['fullText'] = self.fullText
         if self.parts:
-            type_as_dict['parts'] = [part._as_dict_ for part in self.parts if part]
+            type_as_dict['parts'] = [part._as_dict_ for part in self.parts if part is not None]
+        return type_as_dict if type_as_dict != {} else None
         return Serialization.serialize_dict(type_as_dict)
     
     @classmethod
-    def _from_json_(cls, data: dict) -> "NameForm":
-        """Build a NameForm from JSON-like dict."""
-        return cls(
-            lang=data.get("lang", "en"),
-            fullText=data.get("fullText"),
-            parts=[NamePart._from_json_(p) for p in ensure_list(data.get("parts"))],
-        )
+    def _from_json_(cls, data: dict, context=None) -> "NameForm":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict, got {type(data)}")
+
+        name_form = {}
+
+        # Scalars
+        if (lang := data.get("lang")) is not None:
+            name_form["lang"] = lang
+
+        if (full := data.get("fullText")) is not None:
+            name_form["fullText"] = full
+
+        # List of parts
+        if (parts := data.get("parts")) is not None:
+            name_form["parts"] = [NamePart._from_json_(p, context) for p in parts if p]
+
+        return cls(**name_form)
     
     def _fulltext_parts(self):
         pass
@@ -309,29 +346,29 @@ class Name(Conclusion):
     def __init__(self, id: Optional[str] = None,
                  lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = None,
-                 analysis: Resource = None,
+                 analysis: Optional[Document |Resource] = None,
                  notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  type: Optional[NameType] = None,
                  nameForms: Optional[List[NameForm]]= None,
-                 date: Optional[Date] = None) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+                 date: Optional[Date] = None,
+                 links: Optional[_rsLinks] = None) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution,links=links)
         self.type = type
         self.nameForms = nameForms if nameForms else []
         self.date = date
     
-    def _add_name_part(self, namepart_to_add: NamePart):
-        if namepart_to_add and isinstance(namepart_to_add, NamePart):
+    def _add_name_part(self, namepart: NamePart):
+        if namepart and isinstance(namepart, NamePart):
             for current_namepart in self.nameForms[0].parts:
-                if namepart_to_add == current_namepart:
+                if namepart == current_namepart:
                     return False
-            self.nameForms[0].parts.append(namepart_to_add)
+            self.nameForms[0].parts.append(namepart)
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dict = super()._as_dict_
+        type_as_dict = super()._as_dict_ or {}
         if self.type:
             type_as_dict['type'] = getattr(self.type, 'value', self.type)
         if self.nameForms:
@@ -339,23 +376,27 @@ class Name(Conclusion):
         if self.date:
             type_as_dict['date'] = self.date._as_dict_
         
-        return Serialization.serialize_dict(type_as_dict)
+        return type_as_dict if type_as_dict != {} else None
+
     
     @classmethod
-    def _from_json_(cls, data: dict) -> "Name":
+    def _from_json_(cls, data: dict,context = None) -> "Name":
         """Build a Name from JSON-like dict."""
-        return cls(
-            id=data.get("id"),
-            lang=data.get("lang", "en"),
-            sources=[SourceReference._from_json_(s) for s in ensure_list(data.get("sources"))],
-            analysis=Resource._from_json_(data["analysis"]) if data.get("analysis") else None,
-            notes=[Note._from_json_(n) for n in ensure_list(data.get("notes"))],
-            confidence=ConfidenceLevel._from_json_(data["confidence"]) if data.get("confidence") else None,
-            attribution=Attribution._from_json_(data["attribution"]) if data.get("attribution") else None,
-            type=NameType(data["type"]) if data.get("type") else None,
-            nameForms=[NameForm._from_json_(nf) for nf in ensure_list(data.get("nameForms"))],
-            date=Date._from_json_(data["date"]) if data.get("date") else None,
-        )
+        name = Conclusion._dict_from_json_(data)
+        
+        # Enum
+        if (typ := data.get("type")) is not None:
+            name["type"] = NameType(typ)
+
+        # List
+        if (forms := data.get("nameForms")) is not None:
+            name["nameForms"] = [NameForm._from_json_(f, context) for f in forms]
+
+        # Object
+        if (date := data.get("date")) is not None:
+            name["date"] = Date._from_json_(date, context)
+        
+        return cls(**name)
     
     def __str__(self) -> str:
         """Return a human-readable string for the Name-like object."""

gedcomx/note.py

@@ -0,0 +1,105 @@
+from typing import Any, Optional
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    note.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX Name, NameType, NameForm, NamePart Types
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json_ refactor
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .attribution import Attribution
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
+
+class Note:
+    identifier = 'http://gedcomx.org/v1/Note'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,lang: Optional[str] = 'en', subject: Optional[str] = None, text: Optional[str] = None, attribution: Optional[Attribution] = None) -> None:
+        self.lang = lang
+        self.subject = subject
+        self.text = text
+        self.attribution = attribution  
+
+    def append(self, text_to_add: str):
+        if text_to_add and isinstance(text_to_add, str):
+            if self.text:
+                self.text = self.text + text_to_add
+            else:
+                self.text = text_to_add
+        else:
+            return #TODO
+            raise ValueError("The text to add must be a non-empty string.")
+    
+    @property
+    def _as_dict_(self):
+        from .serialization import Serialization
+        type_as_dict = {}
+        if self.lang:
+            type_as_dict["lang"] = self.lang
+        if self.subject:
+            type_as_dict["subject"] = self.subject
+        if self.text:
+            type_as_dict["text"] = self.text
+        if self.attribution:
+            # If attribution exposes `_as_dict_` as a property, use it; otherwise include as-is
+            type_as_dict["attribution"] = getattr(self.attribution, "_as_dict_", self.attribution)
+        return type_as_dict if type_as_dict != {} else None
+        return Serialization.serialize_dict(type_as_dict)    
+    
+    def __eq__(self, other):
+        if not isinstance(other, Note):
+            return NotImplemented
+
+        def safe_str(val):
+            return val.strip() if isinstance(val, str) else ''
+
+        return (
+            #safe_str(self.lang) == safe_str(other.lang) and
+            #safe_str(self.subject) == safe_str(other.subject) and
+            safe_str(self.text) == safe_str(other.text) #and
+           # self.attribution == other.attribution  # Assumes Attribution defines __eq__
+        )
+    
+    @classmethod
+    def _from_json_(cls, data: Any, context=None) -> "Note":
+        # Allow shorthand: "some note text"
+        #if isinstance(data, str):
+        #    return cls(text=data)
+
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+
+        obj: dict[str, Any] = {}
+
+        # Scalars
+        if (lang := data.get("lang")) is not None:
+            obj["lang"] = lang
+        if (subject := data.get("subject")) is not None:
+            obj["subject"] = subject
+        if (text := data.get("text")) is not None:
+            obj["text"] = text
+
+        # Object
+        if (attr := data.get("attribution")) is not None:
+            obj["attribution"] = Attribution._from_json_(attr, context)
+
+        return cls(**obj)

gedcomx/online_account.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+from .resource import Resource
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
+
+class OnlineAccount:
+    identifier = 'http://gedcomx.org/v1/OnlineAccount'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, serviceHomepage: Resource, accountName: str) -> None:
+        pass

gedcomx/{Person.py → person.py}

@@ -11,6 +11,7 @@ from urllib.parse import urljoin
  Created: 2025-08-25
  Updated:
    - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   - 2025-09-03: _from_json_ refactor
    
 ======================================================================
 """
@@ -20,19 +21,32 @@ from urllib.parse import urljoin
 GEDCOM Module Types
 ======================================================================
 """
-from .Attribution import Attribution
-from .Conclusion import ConfidenceLevel
-from .Date import Date
-from .EvidenceReference import EvidenceReference
-from .Extensions.rs10.rsLink import _rsLinkList
-from .Fact import Fact, FactType
-from .Gender import Gender, GenderType
-from .Identifier import IdentifierList
-from .Name import Name, QuickName
-from .Note import Note
-from .Resource import Resource
-from .SourceReference import SourceReference
-from .Subject import Subject
+from .attribution import Attribution
+from .conclusion import ConfidenceLevel
+from .date import Date
+from .evidence_reference import EvidenceReference
+from .Extensions.rs10.rsLink import _rsLinks
+from .fact import Fact, FactType
+from .gender import Gender, GenderType
+from .identifier import IdentifierList
+from .logging_hub import hub, logging
+from .name import Name, QuickName
+from .note import Note
+from .resource import Resource
+from .source_reference import SourceReference
+from .subject import Subject
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+deserial_log = "degedcomx.serialization"
+#=====================================================================
+
+
 
 class Person(Subject):
     """A person in the system.
@@ -60,12 +74,12 @@ class Person(Subject):
              evidence: Optional[List[EvidenceReference]] = None,
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[IdentifierList] = None,
-             private: Optional[bool] = False,
+             private: Optional[bool] = None,
              gender: Optional[Gender] = Gender(type=GenderType.Unknown),
              names: Optional[List[Name]] = None,
              facts: Optional[List[Fact]] = None,
-             living: Optional[bool] = False,
-             links: Optional[_rsLinkList] = None,
+             living: Optional[bool] = None,
+             links: Optional[_rsLinks] = None,
              uri: Optional[Resource] = None) -> None:
         # Call superclass initializer if needed
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers,links=links,uri=uri)
@@ -93,6 +107,7 @@ class Person(Subject):
                     return False
             self.facts.append(fact_to_add)
             return True
+        return False
 
     def add_name(self, name_to_add: Name) -> bool:
         if len(self.names) > 5: 
@@ -105,9 +120,10 @@ class Person(Subject):
                     return False
             self.names.append(name_to_add)
             return True
+        return False
     
     def _add_relationship(self, relationship_to_add: object):
-        from .Relationship import Relationship
+        from .relationship import Relationship
         if isinstance(relationship_to_add,Relationship):
             self._relationships.append(relationship_to_add)
         else:
@@ -127,34 +143,38 @@ class Person(Subject):
 
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dict = super()._as_dict_  
-        if self.private is not None:
-            type_as_dict['private'] = self.private
-        if self.living is not None:
-            type_as_dict['living'] = self.living
-        if self.gender:
-            type_as_dict['gender'] = self.gender._as_dict_
-        if self.names:
-            type_as_dict['names'] = [n._as_dict_ for n in self.names if n]
-        if self.facts:
-            type_as_dict['facts'] = [f._as_dict_ for f in self.facts if f]
-        if self.uri:
-            type_as_dict['uri'] = self.uri._as_dict_
-
-        return Serialization.serialize_dict(type_as_dict)
+        from .serialization import Serialization
+        return Serialization.serialize(self)
+                
            
     @classmethod
-    def _from_json_(cls, data: dict):
-        """
-        Create a Person instance from a JSON-dict (already parsed).
-        """
-        from .Serialization import Serialization
-        return Serialization.deserialize(data, Person)
+    def _from_json_(cls, data: dict, context = None) -> "Person":
+        def _to_bool(v):
+            if isinstance(v, str):
+                return v.strip().lower() in ("1", "true", "yes", "y", "t")
+            return bool(v)
+        with hub.use(deserial_log):
+            log.debug(f"Deserializing a Person")
+            person_data: dict = Subject._dict_from_json_(data,context)
+            if (private := data.get("private")) is not None:
+                person_data["private"] = _to_bool(private)
+            if (living := data.get("living")) is not None:
+                person_data["living"] = _to_bool(living)
+            if (gender := data.get("gender")) is not None:
+                person_data["gender"] = Gender._from_json_(gender, context)
+            if (names := data.get("names")) is not None:
+                person_data["names"] = [Name._from_json_(n, context) for n in names]
+            if (facts := data.get("facts")) is not None:
+                person_data["facts"] = [Fact._from_json_(f, context) for f in facts]
+            
+            diff = data.keys() - person_data.keys()
+            log.debug(f"Desserialization found keys {diff} that are not in deserialization list")
+
+        return cls(**person_data)
 
     @classmethod
     def from_familysearch(cls, pid: str, token: str, *, base_url: Optional[str] = None):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         """
         Fetch a single person by PID from FamilySearch and return a Person.
         - pid: e.g. "KPHP-4B4"
@@ -184,7 +204,7 @@ class Person(Subject):
             raise ValueError(f"FamilySearch returned no person for PID {pid}")
 
         # Keep your existing deserialization helper
-        return Serialization.deserialize(person_json, Person)    
+        return Person._from_json_(person_json)    
 
 class QuickPerson:
     """A GedcomX Person Data Type created with basic information.