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

gedcomx/{Date.py → date.py}

@@ -1,9 +1,34 @@
-from typing import Optional
+from typing import Any, Optional, Dict
 from datetime import datetime, timezone
 from dateutil import parser
-import time
-
-
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    date.py
+ Author:  David J. Cartwright
+ Purpose: 
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json refactored
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 
 class DateFormat:
@@ -25,20 +50,29 @@ class Date:
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         type_as_dict = {}
         if self.original:
             type_as_dict['original'] = self.original
         if self.formal:
             type_as_dict['formal'] = self.formal
+        return type_as_dict if type_as_dict != {} else None
         return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
-    def _from_json_(cls,data):
-        original = data.get('original',None)
-        formal = data.get('formal',None)
+    def _from_json_(cls,data: Any, context=None):
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)} data:{data}")
+
+        date_data: Dict[str, Any] = {}
+
+        # Scalars
+        if (orig := data.get("original")) is not None:
+            date_data["original"] = orig
+        if (formal := data.get("formal")) is not None:
+            date_data["formal"] = formal
         
-        return Date(original=original,formal=formal)
+        return cls(**date_data)
         
 
 

gedcomx/{Document.py → document.py}

@@ -1,12 +1,38 @@
 from enum import Enum
-from typing import Optional, List
+from typing import Any, Dict, List, Optional
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    document.py
+ Author:  David J. Cartwright
+ Purpose: 
 
-from .Attribution import Attribution
-from .Note import Note
-from .SourceReference import SourceReference
-from .Resource import Resource
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json_ refactored 
+   
+======================================================================
+"""
 
-from .Conclusion import Conclusion
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .attribution import Attribution
+from .conclusion import Conclusion, ConfidenceLevel
+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 DocumentType(Enum):
@@ -38,7 +64,7 @@ class Document(Conclusion):
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = None,
-                 confidence: Optional[object] = None, # ConfidenceLevel
+                 confidence: Optional[ConfidenceLevel] = None, # ConfidenceLevel
                  attribution: Optional[Attribution] = None,
                  type: Optional[DocumentType] = None,
                  extracted: Optional[bool] = None, # Default to False
@@ -53,7 +79,7 @@ class Document(Conclusion):
     
     @property
     def _as_dict(self):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         type_as_dict = super()._as_dict_
         if self.type:
             type_as_dict['type'] = self.type.value
@@ -66,9 +92,31 @@ class Document(Conclusion):
         return Serialization.serialize_dict(type_as_dict)
     
     @classmethod
-    def _from_json_(cls, data: dict):
+    def _from_json_(cls, data: Any, context: Any = None) -> "Document":
         """
-        Create a Person instance from a JSON-dict (already parsed).
+        Build a Document from JSON.
+        Shorthand: a bare string becomes {'text': <string>}.
         """
-        type_as_dict = Serialization.get_class_fields('Document')
-        return Serialization.deserialize(data, type_as_dict)
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+
+        obj: Dict[str, Any] = Conclusion._dict_from_json_(data,context)
+
+        # type (enum)
+        if (typ := data.get("type")) is not None:
+            obj["type"] = DocumentType(typ)
+            
+
+        # extracted (bool; accept common string forms)
+        if (ex := data.get("extracted")) is not None:
+            obj["extracted"] = bool(ex)
+
+        # textType (enum)
+        if (tt := data.get("textType")) is not None:
+            obj["textType"] = TextType(tt) 
+
+        # text (string)
+        if (tx := data.get("text")) is not None:
+            obj["text"] = str(tx)
+
+        return cls(**obj)

gedcomx/{Event.py → event.py}

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 """
 ======================================================================
@@ -11,6 +11,8 @@ from typing import List, Optional
  Created: 2025-08-25
  Updated:
    - 2025-08-31: fixed mutible [] in init, replaced List[Identifer] with IdentifierList
+   - 2025-09-03: _from_json_ refactor
+   - 2025-09-04: changed _as_dict_ to std dict creation and removed call to serailization
    
 ======================================================================
 """
@@ -20,17 +22,24 @@ from typing import List, Optional
 GEDCOM Module Type Imports
 ======================================================================
 """
-from .Attribution import Attribution
-from .Conclusion import ConfidenceLevel, Conclusion
-from .Date import Date
-from .EvidenceReference import EvidenceReference
-from .Identifier import IdentifierList
-from .Note import Note
-from .PlaceReference import PlaceReference
-from .Resource import Resource
-from .SourceReference import SourceReference
-from .Subject import Subject
-
+from .attribution import Attribution
+from .conclusion import ConfidenceLevel, Conclusion
+from .date import Date
+from .evidence_reference import EvidenceReference
+from .identifier import IdentifierList
+from .note import Note
+from .place_reference import PlaceReference
+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"
 #=====================================================================
 
 class EventRoleType(Enum):
@@ -103,7 +112,6 @@ class EventRole(Conclusion):
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
         type_as_dict = super()._as_dict_
         if self.person:
             type_as_dict['person'] = Resource(target=self.person)._as_dict_
@@ -112,8 +120,34 @@ class EventRole(Conclusion):
         if self.details:
             type_as_dict['details'] = self.details
 
-        return Serialization.serialize_dict(type_as_dict)
+        return type_as_dict if type_as_dict != {} else None
+
+
+    @classmethod
+    def _from_json_(cls,data,context):
+        
+        if not isinstance(data, dict):
+            print("Event: from:",data)
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+        event_role_data = Conclusion._dict_from_json_(data,context)
+        event_role_data: Dict[str, Any] = {}
+
+        # person: Person | Resource | URI string
+        if (p := data.get("person")) is not None:
+            event_role_data["person"] = Resource._from_json_(p, context)
+            
+
+        # type: EventRoleType (enum-ish)
+        if (typ := data.get("type")) is not None:
+            event_role_data["type"] = EventRoleType(typ)
+            
 
+        # details: TextValue | str
+        if (det := data.get("details")) is not None:
+            event_role_data["details"] = det  # str or passthrough
+
+        return cls(**event_role_data)
+    
 class EventType(Enum):
     Adoption = "http://gedcomx.org/Adoption"
     AdultChristening = "http://gedcomx.org/AdultChristening"
@@ -268,22 +302,45 @@ class Event(Subject):
     
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dict = super()._as_dict_
-        type_as_dict.update({
-            'type': self.type.value if self.type else None,
-            'date': self.date,
-            'place': self.place._as_dict_ if self.place else None,
-            'roles': [role._as_dict_ for role in self.roles],
-        })
-
-        return Serialization.serialize_dict(type_as_dict)
+        from .serialization import Serialization
+        type_as_dict = {}
+        if self.type:
+            type_as_dict['type'] = self.type.value
+        if self.date:
+            type_as_dict['date'] = self.date._as_dict_
+        if self.place:
+            type_as_dict['place'] = self.place._as_dict_ 
+        if self.roles:
+            #print(self.roles)
+            for role in self.roles:
+                if isinstance(role,list):
+                    assert False
+            type_as_dict['roles'] = [role._as_dict_ for role in self.roles]
+        
+        return type_as_dict if type_as_dict != {} else None
+  
     
     @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')
-        from .Serialization import Serialization
-        return Serialization.deserialize(data, Event)
+    def _from_json_(cls, data: Dict[str, Any], context: Any = None) -> "Event":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict, got {type(data)}")
+
+        event_data: Dict[str, Any] = Subject._dict_from_json_(data,context)
+
+        # Enum / type
+        if (typ := data.get("type")) is not None:
+            event_data["type"] = EventType(typ)
+            
+
+        # Objects
+        if (dt := data.get("date")) is not None:
+            event_data["date"] = Date._from_json_(dt, context)
+
+        if (pl := data.get("place")) is not None:
+            event_data["place"] = PlaceReference._from_json_(pl, context)
+
+        # Lists
+        if (rls := data.get("roles")) is not None:
+            event_data["roles"] = [EventRole._from_json_(r, context) for r in rls]
+
+        return cls(**event_data)

gedcomx/evidence_reference.py

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

gedcomx/{Fact.py → fact.py}

@@ -1,28 +1,46 @@
 import difflib
 import re
 
-from datetime import datetime
 from enum import Enum
 from typing import List, Optional, Dict, Any
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    fact.py
+ Author:  David J. Cartwright
+ Purpose: 
 
-from .Attribution import Attribution
-from .Conclusion import ConfidenceLevel
-from .Document import Document
-from .Date import Date
-from .Note import Note
-from .PlaceReference import PlaceReference
-from .SourceReference import SourceReference
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json_ refactor 
+   
+======================================================================
+"""
 
-from .Resource import Resource
-
-from .Conclusion import Conclusion
-from .Qualifier import Qualifier
-
-from enum import Enum
-
-from collections.abc import Sized
-
-from .Extensions.rs10.rsLink import rsLink, _rsLinkList
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+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 .place_reference import PlaceReference
+from .qualifier import Qualifier
+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 FactType(Enum):
@@ -370,7 +388,6 @@ class FactType(Enum):
                 return keywords_to_fact_type[matches[0]]
         return None
 
-
 class FactQualifier(Enum):
     Age = "http://gedcomx.org/Age"
     Cause = "http://gedcomx.org/Cause"
@@ -389,7 +406,6 @@ class FactQualifier(Enum):
         }
         return descriptions.get(self, "No description available.")
 
-
 class Fact(Conclusion):
     identifier = 'http://gedcomx.org/v1/Fact'
     version = 'http://gedcomx.org/conceptual-model/v1'
@@ -397,9 +413,9 @@ class Fact(Conclusion):
     def __init__(self,
                  id: Optional[str] = None,
                  lang: Optional[str] = None,
-                 sources: Optional[List[SourceReference]] = [],
+                 sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource | Document] = None,
-                 notes: Optional[List[Note]] = [],
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  type: Optional[FactType] = None,
@@ -407,7 +423,7 @@ class Fact(Conclusion):
                  place: Optional[PlaceReference] = None,
                  value: Optional[str] = None,
                  qualifiers: Optional[List[FactQualifier]] = None,
-                 links: Optional[_rsLinkList] = None):
+                 links: Optional[_rsLinks] = None):
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, links=links)
         self.type = type
         self.date = date
@@ -428,60 +444,51 @@ class Fact(Conclusion):
 
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dcit = super()._as_dict_
-        # Only add Relationship-specific fields
-        if self.type:
-            type_as_dcit['type'] = getattr(self.type, 'value', self.type)
-        if self.date:
-            type_as_dcit['date'] = self.date._as_dict_
-        if self.place:
-            type_as_dcit['place'] = self.place._as_dict_
-        if self.value:
-            type_as_dcit['value'] = self.value
-        if self.qualifiers:
-            type_as_dcit['qualifiers'] = [getattr(q, 'value', q) for q in self.qualifiers]
+        '''
+        Standard GedcomX Type JSON Serialization
+        Returns: dict that contains only field for which the object has data in
+        '''
+        with hub.use(serial_log):
+            log.debug(f"Serializing 'Fact' with id: {self.id}")
+            type_as_dict = super()._as_dict_ 
+            if type_as_dict is None:
+                log.debug(f"Subject had no fields, creating new dict") 
+                type_as_dict ={}
+            # Only add Relationship-specific fields
+            if self.type:
+                type_as_dict['type'] = getattr(self.type, 'value', self.type)
+            if self.date:
+                type_as_dict['date'] = self.date._as_dict_
+            if self.place:
+                type_as_dict['place'] = self.place._as_dict_
+            if self.value:
+                type_as_dict['value'] = self.value
+            if self.qualifiers and self.qualifiers != []:
+                type_as_dict['qualifiers'] = [getattr(q, 'value', q) for q in self.qualifiers]
+            log.debug(f"'Fact' serialized with fields: {type_as_dict.keys()}") 
+            if type_as_dict == {}: log.warning("serializing and empty 'Fact'")
         
-        return Serialization.serialize_dict(type_as_dcit)
-    
-    @classmethod
-    def _from_json_(cls, data: Dict[str, Any]) -> 'Fact':
+        return type_as_dict if type_as_dict != {} else None 
         
-        # Extract fields, no trailing commas!
-        id_          = data.get('id')
-        lang         = data.get('lang', None)
-        sources      = [SourceReference._from_json_(s) for s in data.get('sources',[])]
-        analysis     = (Resource._from_json_(data['analysis'])
-                        if data.get('analysis') else None)
-        notes        = [Note._from_json_(n) for n in 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)
-        fact_type    = (FactType.from_value(data['type'])
-                        if data.get('type') else None)
-        date         = (Date._from_json_(data['date'])
-                        if data.get('date') else None)
-        place        = (PlaceReference._from_json_(data['place'])
-                        if data.get('place') else None)
-        value        = data.get('value')
-        qualifiers   = [Qualifier._from_json_(q) for q in data.get('qualifiers', [])]
-        links = _rsLinkList._from_json_(data.get('links')) if data.get('links') else None
+    @classmethod
+    def _from_json_(cls, data: Dict[str, Any], context: Any = None) -> "Fact":
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict, got {type(data)}")
+        fact_data = Conclusion._dict_from_json_(data,context)
+        if (val := data.get("value")) is not None:
+            fact_data["value"] = val
+        if (date := data.get("date")) is not None:
+            fact_data["date"] = Date._from_json_(date, context)
+        if (place := data.get("place")) is not None:
+            fact_data["place"] = PlaceReference._from_json_(place, context)
+        if (ft := data.get("type")) is not None:
+            fact_data["type"] = FactType(ft)
+        if (quals := data.get("qualifiers")) is not None:
+            fact_data["qualifiers"] = [Qualifier._from_json_(q) for q in quals if q is not None] 
+            
+        return cls(**fact_data) 
 
-        return cls(
-            id=id_,
-            lang=lang,
-            sources=sources,
-            analysis=analysis,
-            notes=notes,
-            confidence=confidence,
-            attribution=attribution,
-            type=fact_type,
-            date=date,
-            place=place,
-            value=value,
-            qualifiers=qualifiers,
-            links=links
-        )
+        
 
 
 

gedcomx/{Gedcom.py → gedcom.py}

@@ -1,5 +1,15 @@
 import re
 
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
+
 class Gedcom():
     def __init__(self) -> None:
         pass

gedcomx/{Gedcom5x.py → gedcom5x.py}

@@ -9,7 +9,16 @@ from collections import defaultdict
 from typing import Iterable, Iterator, List, Optional, Tuple, Union
 
 import logging
-from .LoggingHub import hub, ChannelConfig
+from .logging_hub import hub, ChannelConfig
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 job_id = "gedcomx.parsing.GEDCOM5x"
 
@@ -64,18 +73,17 @@ from typing import List, Optional, Iterator, Union
 
 
 class Gedcom5xRecord():
-    def __init__(
-        self,
-        line_num: Optional[int] = None,
-        level: int = -1,
-        tag: str | None = "NONR",
-        xref: Optional[str] = None,
-        value: Optional[str] = None,
-    ) -> None:
+    def __init__(self,
+                    line_num: Optional[int] = None,
+                    level: int = -1,
+                    tag: str | None = "NONR",
+                    xref: Optional[str] = None,
+                    value: Optional[str] = None,
+                ) -> None:
         self.line = line_num
         self._subRecords: List[Gedcom5xRecord] = []
         self.level = int(level)
-        self.xref = xref
+        self.xref = xref.replace('@','') if xref else ''
         self.pointer: bool = False
         self.tag = str(tag).strip()
         self.value = value
@@ -144,7 +152,7 @@ class Gedcom5xRecord():
     # ───────────────────────────────
     def subRecord(self, tag: str):
         result = [r for r in self._subRecords if r.tag == tag]
-        return [] if not result else result
+        return None if not result else result
 
     def subRecords(self, tag: str | None = None) -> List['Gedcom5xRecord']:
         if not tag:
@@ -367,7 +375,8 @@ class Gedcom5x():
         import json
         return json.dumps({'Individuals': [indi._as_dict_ for indi in self._individuals]},indent=4)
 
-    def stats(self):
+    @property
+    def contents(self):
         def print_table(pairs):
 
             # Calculate the width of the columns
@@ -385,16 +394,16 @@ class Gedcom5x():
             for name, value in pairs:
                 print(f"{name.ljust(name_width)} | {str(value).ljust(value_width)}")
                 
-        imports_stats = [
-            ('Top Level Records', len(self.records)),
-            ('Individuals', len(self.individuals)),
-            ('Family Group Records', len(self.families)),
-            ('Repositories', len(self.repositories)),
-            ('Sources', len(self.sources)),
-            ('Objects', len(self.objects))
-        ]
+        imports_stats = {
+            'Top Level Records': len(self.records),
+            'Individuals': len(self.individuals),
+            'Family Group Records': len(self.families),
+            'Repositories': len(self.repositories),
+            'Sources': len(self.sources),
+            'Objects': len(self.objects)
+        }
 
-        print_table(imports_stats)
+        return imports_stats
 
     @property
     def sources(self) -> List[Gedcom5xRecord]:
@@ -475,6 +484,7 @@ class Gedcom5x():
 
             level = int(match.group("level"))
             xref_id = match.group("xref")
+            xref_id = xref_id.strip('@') if xref_id else None
             tag = match.group("tag")
             value = match.group("value")
             if value == 'None': value = None