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

gedcomx/gedcomx.py

@@ -3,8 +3,10 @@ DEBUG = False
 import json
 import random
 import string
+import orjson
 
-from typing import Any, Dict, Optional
+from functools import lru_cache
+from typing import Any, Dict, List, Optional
 
 """
 ======================================================================
@@ -15,8 +17,9 @@ from typing import Any, Dict, Optional
 
  Created: 2025-07-25
  Updated:
-   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data,
+    - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data,
     id_index functionality, will be used for resolution of Resources
+    - 2025-09-03: _from_json_ refactor
    
 ======================================================================
 """
@@ -32,7 +35,7 @@ from .document import Document
 from .event import Event
 from .group import Group
 from .identifier import make_uid
-from .Logging import get_logger
+from .logging_hub import logging, hub, ChannelConfig
 from .person import Person
 from .place_description import PlaceDescription
 from .relationship import Relationship, RelationshipType
@@ -42,6 +45,11 @@ from .textvalue import TextValue
 from .uri import URI
 #=====================================================================
 
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+deserial_log = "gedcomx.serialization"
+
+
 
 def TypeCollection(item_type):
     """
@@ -105,17 +113,20 @@ def TypeCollection(item_type):
                 assert False
 
             # Update the name index
-            ''' #TODO Fix name handling on persons
+             #TODO Fix name handling on persons
             if hasattr(item, 'names'):
                 names = getattr(item, 'names')
                 for name in names:
-                    print(name._as_dict_)
-                    name_value = name.value if isinstance(name, TextValue) else name
-                    if name_value in self._name_index:
-                        self._name_index[name_value].append(item)
+                    #print(name._as_dict_)
+                    if isinstance(name, TextValue):
+                        name_value = name.value 
+                        if name_value in self._name_index:
+                            self._name_index[name_value].append(item)
+                        else:
+                            self._name_index[name_value] = [item]
                     else:
-                        self._name_index[name_value] = [item]
-            '''
+                        pass
+            
         @property
         def id_index(self):
             return self._id_index
@@ -155,6 +166,7 @@ def TypeCollection(item_type):
         def append(self, item):
             if not isinstance(item, item_type):
                 raise TypeError(f"Expected item of type {item_type.__name__}, got {type(item).__name__}")
+            #if item.id in self.id_index: assert False
             if item.uri:
                 item.uri.path  = f'{str(item_type.__name__)}s' if (item.uri.path is None or item.uri.path == "") else item.uri.path
             else:
@@ -163,6 +175,13 @@ def TypeCollection(item_type):
             self._items.append(item)
             self._update_indexes(item)
 
+        def extend(self, items: list):
+            """Add multiple items to the collection at once."""
+            if not isinstance(items, (list, tuple)):
+                raise TypeError("extend() expects a list or tuple of items")
+            for item in items:
+                self.append(item)
+
         def remove(self, item):
             if item not in self._items:
                 raise ValueError("Item not found in the collection.")
@@ -235,30 +254,40 @@ class GedcomX:
     def __init__(self, id: Optional[str] = None,
                  attribution: Optional[Attribution] = None,
                  filepath: Optional[str] = None,
-                 description: Optional[str] = None) -> None:
+                 description: Optional[str] = None,
+                 persons: Optional[List[Person]] = None,
+                 relationships: Optional[List[Relationship]] = None,
+                 sourceDescriptions: Optional[List[SourceDescription]] = None,
+                 agents:  Optional[List[Agent]] = None,
+                 places: Optional[List[PlaceDescription]] = None) -> None:
         
         self.id = id
         self.attribution = attribution
         self._filepath = None
         
         self.description = description
-        self.source_descriptions = TypeCollection(SourceDescription)
+        self.sourceDescriptions = TypeCollection(SourceDescription)
+        if sourceDescriptions: self.sourceDescriptions.extend(sourceDescriptions)
         self.persons = TypeCollection(Person)
-        self.relationships = TypeCollection(Relationship)      
+        if persons: self.persons.extend(persons)
+        self.relationships = TypeCollection(Relationship)
+        if relationships: self.relationships.extend(relationships)      
         self.agents = TypeCollection(Agent)
+        if agents: self.agents.extend(agents) 
         self.events = TypeCollection(Event)
         self.documents = TypeCollection(Document)
         self.places = TypeCollection(PlaceDescription)
+        if places: self.places.extend(places)
         self.groups = TypeCollection(Group)
 
         self.relationship_table = {}
 
-        self.default_id_generator = make_uid
+        #self.default_id_generator = make_uid
 
     @property
     def contents(self):
         return {
-            "source_descriptions": len(self.source_descriptions),
+            "source_descriptions": len(self.sourceDescriptions),
             "persons": len(self.persons),
             "relationships": len(self.relationships),
             "agents": len(self.agents),
@@ -290,8 +319,8 @@ class GedcomX:
     def add_source_description(self,sourceDescription: SourceDescription):
         if sourceDescription and isinstance(sourceDescription,SourceDescription):
             if sourceDescription.id is None:
-                sourceDescription.id =self.default_id_generator()
-            self.source_descriptions.append(item=sourceDescription)
+                assert False
+            self.sourceDescriptions.append(item=sourceDescription)
             self.lastSourceDescriptionAdded = sourceDescription
         else:
             raise ValueError(f"When adding a SourceDescription, value must be of type SourceDescription, type {type(sourceDescription)} was provided")
@@ -318,7 +347,6 @@ class GedcomX:
     def add_relationship(self,relationship: Relationship):
         if relationship and isinstance(relationship,Relationship):
             if isinstance(relationship.person1,Resource) and isinstance(relationship.person2,Resource):
-                print("Adding unresolved Relationship")
                 self.relationships.append(relationship)
                 return
             elif isinstance(relationship.person1,Person) and isinstance(relationship.person2,Person):
@@ -358,26 +386,13 @@ class GedcomX:
             self.places.append(placeDescription)
 
     def add_agent(self,agent: Agent):
-        """Add a Agent object to the Genealogy
-
-        Args:
-            agent: Agent Object
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: If `agent` is not of type Agent.
-        """
-        if agent and isinstance(agent,Agent):
-            if agent in self.agents:
-                return
-            if agent.id is None:
-                agent.id = make_uid()
-            if self.agents.byId(agent.id):
-                pass #TODO Deal with duplicates
-                #raise ValueError
+        if isinstance(agent,Agent) and agent is not None:
+            if self.agents.byId(agent.id) is not None:   
+                print(f"Did not add agent with Duplicate ID")  
+                return False  
             self.agents.append(agent)
+        else:
+            raise ValueError()
     
     def add_event(self,event_to_add: Event):
         if event_to_add and isinstance(event_to_add,Event):
@@ -387,24 +402,27 @@ class GedcomX:
                     print("DUPLICATE EVENT")
                     print(event_to_add._as_dict_)
                     print(current_event._as_dict_)
+                    
                     return
             self.events.append(event_to_add)
         else:
             raise ValueError
 
+    @lru_cache(maxsize=65536)
     def get_person_by_id(self,id: str):
         filtered = [person for person in self.persons if getattr(person, 'id') == id]
         if filtered: return filtered[0]
         return None
-    
-    def source(self,id: str):
-        filtered = [source for source in self.source_descriptions if getattr(source, 'id') == id]
+     
+    @lru_cache(maxsize=65536)
+    def source_by_id(self,id: str):
+        filtered = [source for source in self.sourceDescriptions if getattr(source, 'id') == id]
         if filtered: return filtered[0]
         return None        
 
     @property
     def id_index(self):
-        combined = {**self.source_descriptions.id_index,
+        combined = {**self.sourceDescriptions.id_index,
                     **self.persons.id_index,
                     **self.relationships.id_index,
                     **self.agents.id_index,
@@ -419,78 +437,62 @@ class GedcomX:
 
     @property
     def _as_dict(self) -> dict[str, Any]:
-        type_as_dict: Dict[str, Any] = {}
-
-        if self.persons and len(self.persons) > 0:
-            type_as_dict["persons"] = [person._as_dict_ for person in self.persons]
-
-        if self.source_descriptions:
-            type_as_dict["sourceDescriptions"] = [
-                sd._as_dict_ for sd in self.source_descriptions
-            ]
-
-        if self.relationships:
-            type_as_dict["relationships"] = [
-                rel._as_dict_ for rel in self.relationships
-            ]
-
-        if self.agents:
-            type_as_dict["agents"] = [agent._as_dict_ for agent in self.agents]
-
-        if self.events:
-            type_as_dict["events"] = [event._as_dict_ for event in self.events]
-
-        if self.places:
-            type_as_dict["places"] = [place._as_dict_ for place in self.places]
-
-        if self.documents:
-            type_as_dict["documents"] = [doc._as_dict_ for doc in self.documents]
-
-        return type_as_dict
+        from .serialization import Serialization
+        return Serialization.serialize(self)
+        
 
     @property
-    def json(self):
+    def json(self) -> bytes:
         """
         JSON Representation of the GedcomX Genealogy.
 
         Returns:
             str: JSON Representation of the GedcomX Genealogy in the GEDCOM X JSON Serialization Format
         """
-        gedcomx_json = {
-            'persons': [person._as_dict_ for person in self.persons],
-            'sourceDescriptions' : [sourceDescription._as_dict_ for sourceDescription in self.source_descriptions],
-            'relationships': [relationship._as_dict_ for relationship in self.relationships],
-            'agents': [agent._as_dict_ for agent in self.agents],
-            'events': [event._as_dict_ for event in self.events],
-            'places': [place._as_dict_ for place in self.places],
-            'documents': [document._as_dict_ for document in self.documents],
-        }
-        return json.dumps(gedcomx_json, indent=4)
+        return orjson.dumps(self._as_dict,option= orjson.OPT_INDENT_2 | orjson.OPT_APPEND_NEWLINE)
+        
 
     @staticmethod
     def from_json(data: dict):
         from .serialization import Serialization
         gx = GedcomX()
+
+        persons = data.get('persons', [])
+        for person in persons:
+            if (person := Person._from_json_(person)) is not None:
+                gx.add_person(person)
         
         source_descriptions = data.get('sourceDescriptions', [])
         for source in source_descriptions:
-            gx.add_source_description(Serialization.deserialize(source,SourceDescription))     
-        
-        persons = data.get('persons', [])
-        for person in persons:
-            gx.add_person(Serialization.deserialize(person,Person))
+            if (source_description := SourceDescription._from_json_(source)) is not None:
+                gx.add_source_description(source_description)         
         
         relationships = data.get('relationships', [])
-        for relationship in relationships:
-            gx.add_relationship(Serialization.deserialize(relationship,Relationship))
-        
-        agents = data.get('agents', [])
-        for agent in agents:
-            gx.add_agent(Serialization.deserialize(agent,Agent))
+        for rel in relationships:
+            if (relationship := Relationship._from_json_(rel)) is not None:
+                gx.add_relationship(relationship)
 
+        agents = data.get('agents', [])
+        for agent_data in agents:
+            if (agent := Agent._from_json_(agent_data)) is not None:
+                gx.add_agent(agent)
+            else:
+                raise ValueError()
+        
         events = data.get('events', [])
-        for event in events:
-            gx.add_event(Serialization.deserialize(event,Event))
+        for event_data in events:
+            if (event := Event._from_json_(event_data)) is not None:
+                gx.add_event(event)
+                
+        places = data.get('places', [])
+        for place_data in places:
+            if (place := PlaceDescription._from_json_(place_data)) is not None:
+                gx.add_place_description(place)
+        
+        documents = data.get('documents', [])
+        for doc_data in documents:
+            if (event := Document._from_json_(event_data)) is not None:
+                pass
         
         return gx
         

gedcomx/gender.py

@@ -9,7 +9,7 @@ from typing import List, Optional
 
  Created: 2025-08-25
  Updated:
-   - 2025-08-31: 
+   - 2025-09-03: _from_json_ refactor 
    
 ======================================================================
 """
@@ -21,9 +21,18 @@ GEDCOM Module Types
 """
 from .attribution import Attribution
 from .conclusion import ConfidenceLevel, Conclusion
+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"
 #=====================================================================
 
 
@@ -55,25 +64,28 @@ class Gender(Conclusion):
                  notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None, 
-                 type: Optional[GenderType] = None
+                 type: Optional[GenderType] = None,
+                 links: Optional[_rsLinks] = None
                  ) -> None:
-        super().__init__(id=id, lang=lang, sources=sources, analysis=analysis, notes=notes, confidence=confidence, attribution=attribution)
+        super().__init__(id=id, lang=lang, sources=sources, analysis=analysis, notes=notes, confidence=confidence, attribution=attribution, links=links)
         self.type = type
     
     @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'] = self.type.value if self.type else None                   
         
+        return type_as_dict if type_as_dict != {} else None
         
-        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
-    def _from_json_(cls,data):
-        from .serialization import Serialization
+    def _from_json_(cls,data,context):
+        conclusion = Conclusion._dict_from_json_(data,context)
+        if (type_ := data.get("type")) is not None:
+            conclusion["type"] = GenderType(type_)
         
-        return Serialization.deserialize(data, Gender)
+        return cls(**conclusion)
         
         

gedcomx/group.py

@@ -32,6 +32,15 @@ from .resource import Resource
 
 from .textvalue import TextValue
 from .subject import Subject
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 class GroupRoleType(Enum):                              #TODO Impliment
     def __init__(self) -> None:

gedcomx/identifier.py

@@ -1,18 +1,44 @@
-
-from enum import Enum
-
 from typing import List, Optional, Dict, Any
-
 from collections.abc import Iterator
 import json
-from .resource import Resource
-from .uri import URI
-from .extensible_enum import ExtensibleEnum
-
 import secrets
 import string
 import json
 
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    identifier.py
+ Author:  David J. Cartwright
+ Purpose: 
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json_ refactor 
+   - 2025-09-04: fixe identifier and identifieList json deserialization
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .extensible_enum import _EnumItem
+from .resource import Resource
+from .uri import URI
+from .extensible_enum import ExtensibleEnum
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
+
 def make_uid(length: int = 10, alphabet: str = string.ascii_letters + string.digits) -> str:
     """
     Generate a cryptographically secure alphanumeric UID.
@@ -38,6 +64,7 @@ IdentifierType.register("Deprecated", "http://gedcomx.org/Deprecated")
 IdentifierType.register("Persistent", "http://gedcomx.org/Persistent")
 IdentifierType.register("External", "https://gedcom.io/terms/v7/EXID")
 IdentifierType.register("Other", "user provided")
+IdentifierType.register("ChildAndParentsRelationship","http://familysearch.org/v1/ChildAndParentsRelationship")
     
 class Identifier:
     identifier = 'http://gedcomx.org/v1/Identifier'
@@ -54,9 +81,9 @@ class Identifier:
         from .serialization import Serialization
         type_as_dict = {}
         if self.values:
-            type_as_dict["value"] = list(self.values)  # or [v for v in self.values]
+            type_as_dict["value"] = None # [v._as_dict_ for v in self.values]
         if self.type:
-            type_as_dict["type"] = getattr(self.type, "value", self.type)  # type: ignore[attr-defined]
+            type_as_dict["type"] = None #getattr(self.type, "value", self.type)  # type: ignore[attr-defined]
 
         return Serialization.serialize_dict(type_as_dict)
 
@@ -116,16 +143,13 @@ class IdentifierList:
             self.add_identifier(identifier)
         else:
             raise ValueError("append expects an Identifier instance")
-
-    # keep the old name working; point it at the corrected spelling
-    def add_identifer(self, identifier: "Identifier"):  # backward-compat alias
-        return self.add_identifier(identifier)
-
+    
     def add_identifier(self, identifier: "Identifier"):
         """Add/merge an Identifier (which may contain multiple values)."""
         if not (identifier and isinstance(identifier, Identifier) and identifier.type):
             raise ValueError("The 'identifier' must be a valid Identifier instance with a type.")
-
+        if not isinstance(identifier.type,_EnumItem):
+            raise ValueError
         key = identifier.type.value if hasattr(identifier.type, "value") else str(identifier.type)
         existing = self.identifiers.get(key, [])
         merged = self.unique_list(list(existing) + list(identifier.values))
@@ -193,12 +217,12 @@ class IdentifierList:
                 yield (k, v)
     
     @classmethod
-    def _from_json_(cls, data):
+    def _from_json_(cls, data,context=None):
         if isinstance(data, dict):
             identifier_list = IdentifierList()
             for key, vals in data.items():
                 # Accept both single value and list in JSON
-                vals = vals if isinstance(vals, list) else [vals]
+                vals = [URI._from_json_(v) for v in vals]
                 identifier_list.add_identifier(
                     Identifier(value=vals, type=IdentifierType(key))
                 )
@@ -208,8 +232,11 @@ class IdentifierList:
 
     @property
     def _as_dict_(self):
-        # If you want a *copy*, return `dict(self.identifiers)`
-        return self.identifiers
+        type_as_dict = {}
+        for k in self.identifiers.keys():
+            #print(k,self.identifiers[k],type(self.identifiers[k]))
+            type_as_dict[k] = [i._as_dict_ for i in self.identifiers[k]]
+        return type_as_dict if type_as_dict != {} else None
 
     def __repr__(self) -> str:
         return json.dumps(self._as_dict_, indent=4)

gedcomx/logging_hub.py

@@ -203,5 +203,24 @@ hub.start_channel(
     make_current=True
 )
 
+serial_log = "gedcomx.serialization"
+deserial_log = "gedcomx.deserialization"
+
+hub.start_channel(
+    ChannelConfig(
+        name=serial_log,
+        path=f"logs/{serial_log}.log",
+        level=logging.DEBUG,
+        rotation="size:10MB:3",   # rotate by size, keep 3 backups
+    ))
+
+hub.start_channel(
+    ChannelConfig(
+        name=deserial_log,
+        path=f"logs/{deserial_log}.log",
+        level=logging.DEBUG,
+        rotation="size:10MB:3",   # rotate by size, keep 3 backups
+    ))
+
 # (optional) Also a console channel you can switch to
 hub.start_channel(ChannelConfig(name="console", path=None, level=logging.DEBUG))

gedcomx/mutations.py

@@ -23,6 +23,14 @@ 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 = {
@@ -243,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)