gedcom-x 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

gedcomx/name.py

@@ -11,6 +11,7 @@ from typing import List,Optional
  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
    
 ======================================================================
 """
@@ -25,10 +26,19 @@ 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):
@@ -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):
@@ -233,17 +258,29 @@ class NameForm:
         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
@@ -315,8 +352,9 @@ class Name(Conclusion):
                  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
@@ -330,8 +368,7 @@ class Name(Conclusion):
     
     @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

@@ -1,6 +1,33 @@
-from typing import Optional
+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'
@@ -35,6 +62,7 @@ class Note:
         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):
@@ -52,22 +80,26 @@ class Note:
         )
     
     @classmethod
-    def _from_json_(cls, data: dict):
-        """
-        Create a Note instance from a JSON-dict (already parsed).
-        """
-        # Basic scalar fields
-        lang     = data.get('lang', 'en')
-        text     = data.get('text')
-        subject  = data.get('subject')
-        # Add other fields as needed
+    def _from_json_(cls, data: Any, context=None) -> "Note":
+        # Allow shorthand: "some note text"
+        #if isinstance(data, str):
+        #    return cls(text=data)
 
-        # Build the instance
-        inst = cls(
-            lang    = lang,
-            text    = text,
-            subject = subject,
-            # Add other fields as needed
-        )
+        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 inst
+        return cls(**obj)

gedcomx/online_account.py

@@ -1,6 +1,15 @@
 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'

gedcomx/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
    
 ======================================================================
 """
@@ -24,17 +25,31 @@ from .attribution import Attribution
 from .conclusion import ConfidenceLevel
 from .date import Date
 from .evidence_reference import EvidenceReference
-from .Extensions.rs10.rsLink import _rsLinkList
+from .Extensions.rs10.rsLink import _rsLinks
+from .extensible import Extensible
 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):
+
+class Person(Extensible,Subject):
     """A person in the system.
 
     Args:
@@ -60,12 +75,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)
@@ -130,29 +145,33 @@ 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)
+        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):
@@ -186,7 +205,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.

gedcomx/place_description.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 """
 ======================================================================
@@ -10,6 +10,7 @@ from typing import List, Optional
  Created: 2025-08-25
  Updated:
    - 2025-09-01: filename PEP8 standard
+   - 2025-09-03: _from_json_ refactored
    
 ======================================================================
 """
@@ -23,6 +24,7 @@ from .attribution import Attribution
 from .conclusion import ConfidenceLevel
 from .date import Date
 from .evidence_reference import EvidenceReference
+from .Extensions.rs10.rsLink import _rsLinks #new
 from .identifier import IdentifierList
 from .note import Note
 from .resource import Resource
@@ -30,6 +32,14 @@ from .source_reference import SourceReference
 from .subject import Subject
 from .textvalue import TextValue
 from .uri import URI
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
 #=====================================================================
 
 
@@ -78,9 +88,11 @@ class PlaceDescription(Subject):
                  latitude: Optional[float] = None,
                  longitude: Optional[float] = None,
                  temporalDescription: Optional[Date] = None,
-                 spatialDescription: Optional[Resource] = None,) -> None:
+                 spatialDescription: Optional[Resource] = None,
+                 links: Optional[_rsLinks] = None
+                 ) -> 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,links=links)
         self.names = names
         self.type = type
         self.place = place
@@ -93,7 +105,7 @@ class PlaceDescription(Subject):
     @property
     def _as_dict_(self):
         from .serialization import Serialization
-        type_as_dict = super()._as_dict_
+        type_as_dict = super()._as_dict_ or {}
         
         if self.names:
             type_as_dict["names"] = [n._as_dict_ for n in self.names if n]
@@ -112,12 +124,46 @@ class PlaceDescription(Subject):
         if self.spatialDescription:
             type_as_dict["spatialDescription"] = self.spatialDescription._as_dict_
 
+        return type_as_dict if type_as_dict != {} else None
         return Serialization.serialize_dict(type_as_dict) 
 
     @classmethod
-    def _from_json_(cls, data: dict):
+    def _from_json_(cls, data: Any, context: Any = None) -> "PlaceDescription":
         """
         Create a PlaceDescription instance from a JSON-dict (already parsed).
-        """
-        from .serialization import Serialization
-        return Serialization.deserialize(data, PlaceDescription)   
+        """        
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+
+        person_data: Dict[str, Any] = Subject._dict_from_json_(data,context)
+
+        # names (allow both list and a single 'name' alias)
+        if (names := data.get("names")) is not None:
+            person_data["names"] = [TextValue._from_json_(n, context) for n in names]
+        
+        # type (string for now; promote to enum later)
+        if (typ := data.get("type")) is not None:
+            person_data["type"] = typ
+
+        # place: URI (accept string or dict)
+        if (pl := data.get("place")) is not None:
+            person_data["place"] = URI(pl)
+
+        # jurisdiction: Resource | PlaceDescription
+        if (jur := data.get("jurisdiction")) is not None:
+            person_data["jurisdiction"] = Resource._from_json_(jur, context)
+            
+        # coordinates
+        if (lat := data.get("latitude")) is not None:
+            person_data["latitude"] = float(lat)
+        if (lon := data.get("longitude")) is not None:
+            person_data["longitude"] = float(lon)
+
+        # temporal / spatial descriptions
+        if (td := data.get("temporalDescription")) is not None:
+            person_data["temporalDescription"] = Date._from_json_(td, context)
+
+        if (sd := data.get("spatialDescription")) is not None:
+            person_data["spatialDescription"] = Resource._from_json_(sd, context)
+
+        return cls(**person_data)   

gedcomx/place_reference.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
  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 refactored
    
 ======================================================================
 """
@@ -23,6 +24,16 @@ GEDCOM Module Types
 ======================================================================
 """
 from .resource import Resource
+from .logging_hub import hub, logging
+from .uri import URI
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 class PlaceReference:
     """defines a reference to a PlaceDescription.
@@ -39,24 +50,35 @@ class PlaceReference:
     
     def __init__(self,
                  original: Optional[str] = None,
-                 description: Optional["Resource | PlaceDescription"] = None) -> None:
+                 description: Optional["URI | PlaceDescription"] = None) -> None:
         self.original = original
-        self.description = description
+        self.description = description # descriptionRef
 
     @property
     def _as_dict_(self):
-        from .serialization import Serialization
+        
         type_as_dict = {}
         if self.original:
             type_as_dict['original'] = self.original
         if self.description:
-            type_as_dict['description'] = self.description._as_dict_ 
-        return Serialization.serialize_dict(type_as_dict)
+            type_as_dict['description'] = URI(target=self.description)._as_dict_ 
+        return type_as_dict if type_as_dict != {} else None
+        
     
     @classmethod
-    def _from_json_(cls, data):
-        from .serialization import Serialization
-        return Serialization.deserialize(data, PlaceReference)
+    def _from_json_(cls, data, context=None) -> "PlaceReference":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+
+        place_reference_data = {}
+
+        # Scalars
+        if (orig := data.get("original")) is not None:
+            place_reference_data["original"] = orig
+        if (desc := data.get("description")) is not None:
+            place_reference_data["description"] = URI._from_json_(desc, context)
+        
+        return cls(**place_reference_data)
 
 
 

gedcomx/qualifier.py

@@ -11,9 +11,19 @@ from typing import Optional
  Updated:
    - 2025-08-31: _as_dict_ to only create entries in dict for fields that 
    hold data, updated _from_json
+   - 2025-09-03: _from_json_ refactor
    
 ======================================================================
 """
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 class Qualifier:
     """defines the data structure used to supply additional details, annotations,
@@ -45,10 +55,16 @@ class Qualifier:
         if self.value:
             type_as_dict["value"] = self.value
         
+        return type_as_dict if type_as_dict != {} else None
         return Serialization.serialize_dict(type_as_dict)
     
     @classmethod
-    def _from_json(cls,data):
-        qualifier = Qualifier(name=data.get('name',"ERROR: This Qualifier require a 'name' but has none."),value=data.get('value'))
-        return qualifier
+    def _from_json_(cls, data: dict, context=None) -> "Qualifier":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict, got {type(data)}")
+
+        name = data.get("name")
+        value = data.get("value")
+
+        return cls(name=name, value=value)