gedcom-x 0.5.2__py3-none-any.whl → 0.5.5__py3-none-any.whl

gedcomx/GedcomX.py

@@ -20,10 +20,10 @@ from .Exceptions import TagConversionError
 from .Event import Event,EventType,EventRole,EventRoleType
 from .Fact import Fact, FactType, FactQualifier
 from .Gedcom import Gedcom
-from .Gedcom import GedcomRecord
+from .Gedcom5x import GedcomRecord
 from .Gender import Gender, GenderType
 from .Group import Group
-from .Identifier import Identifier, IdentifierType
+from .Identifier import Identifier, IdentifierType, make_uid, IdentifierList
 from .Logging import get_logger
 from .Name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
 from .Note import Note
@@ -129,7 +129,10 @@ 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__}")
-            item.uri.path  = f'{str(item_type.__name__)}s' if (item.uri.path is None or item.uri.path == "") else item.uri.path
+            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:
+                item.uri = URI(path=f'/{item_type.__name__}s/')
             
             
             #if isinstance(item,Agent):
@@ -208,10 +211,13 @@ class GedcomX:
     """
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str = None, attribution: Attribution = None, filepath: str = None, description: str = None) -> None:
+    def __init__(self, id: Optional[str] = None,
+                 attribution: Optional[Attribution] = None,
+                 filepath: Optional[str] = None,
+                 description: Optional[str] = None) -> None:
+        
         self.id = id
         self.attribution = attribution
-
         self._filepath = None
         
         self.description = description
@@ -224,9 +230,11 @@ class GedcomX:
         self.places = TypeCollection(PlaceDescription)
         self.groups = TypeCollection(Group)
 
-        self.person_relationships_lookup = {}
+        self.relationship_table = {}
+
+        self.default_id_generator = make_uid
 
-    def _add(self,gedcomx_type_object):
+    def add(self,gedcomx_type_object):
         if gedcomx_type_object:
             if isinstance(gedcomx_type_object,Person):
                 self.add_person(gedcomx_type_object)
@@ -285,24 +293,24 @@ class GedcomX:
                     relationship.person1.id = self.personURIgenerator()
                 if not self.persons.byId(relationship.person1.id):
                     self.persons.append(relationship.person1)
-                if relationship.person1.id not in self.person_relationships_lookup:
-                    self.person_relationships_lookup[relationship.person1.id] = []
-                self.person_relationships_lookup[relationship.person1.id].append(relationship)
+                if relationship.person1.id not in self.relationship_table:
+                    self.relationship_table[relationship.person1.id] = []
+                self.relationship_table[relationship.person1.id].append(relationship)
                 relationship.person1._add_relationship(relationship)
             else:
-                raise ValueError
+                pass
             
             if relationship.person2:
                 if relationship.person2.id is None:
                     relationship.person2.id = self.personURIgenerator() #TODO
                 if not self.persons.byId(relationship.person2.id):
                     self.persons.append(relationship.person2)
-                if relationship.person2.id not in self.person_relationships_lookup:
-                    self.person_relationships_lookup[relationship.person2.id] = []
-                self.person_relationships_lookup[relationship.person2.id].append(relationship)
+                if relationship.person2.id not in self.relationship_table:
+                    self.relationship_table[relationship.person2.id] = []
+                self.relationship_table[relationship.person2.id].append(relationship)
                 relationship.person2._add_relationship(relationship)
             else:
-                raise ValueError
+                pass
 
             self.relationships.append(relationship)
         else:
@@ -311,7 +319,7 @@ class GedcomX:
     def add_place_description(self,placeDescription: PlaceDescription):
         if placeDescription and isinstance(placeDescription,PlaceDescription):
             if placeDescription.id is None:
-                placeDescription.id = self.PlaceDescriptionURIGenerator()
+                Warning("PlaceDescription has no id")
             self.places.append(placeDescription)
 
     def add_agent(self,agent: Agent):
@@ -362,7 +370,12 @@ class GedcomX:
         """
         gedcomx_json = {
             'persons': [person._as_dict_ for person in self.persons],
-            'sourceDescriptions' : [sourceDescription._as_dict_ for sourceDescription in self.source_descriptions]
+            '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)
 
@@ -852,6 +865,8 @@ class Translater():
                         self.object_stack.append(gxobject)
                         self.object_map[record.level] = gxobject
                     else:
+                        convert_log.warning(f"Could not convert EVEN '{value}' for object of type {type(self.object_map[record.level-1])} in record {record.describe()}")
+                        return
                         raise TagConversionError(record=record,levelstack=self.object_map)
                         assert False
                         # TODO: Fix, this. making an event to cacth subtags, why are these fact tied to a source? GEDCOM is horrible
@@ -1064,7 +1079,7 @@ class Translater():
     def handle_page(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], SourceReference):
             self.object_map[record.level-1].descriptionId = record.value
-            self.object_map[record.level-1].add_qualifier(KnownSourceReference.Page)
+            self.object_map[record.level-1].add_qualifier(KnownSourceReference(name=str(KnownSourceReference.Page),value=record.value))
             
             #self.object_stack.append(gxobject)
             #self.object_map[record.level] = gxobject
@@ -1081,21 +1096,21 @@ class Translater():
             self.object_map[record.level] = gxobject
         elif isinstance(self.object_map[record.level-1], Event):
             if self.gedcomx.places.byName(record.value):
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, descriptionRef=self.gedcomx.places.byName(record.value)[0])
+                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=self.gedcomx.places.byName(record.value)[0])
             else:
                 place_des = PlaceDescription(names=[TextValue(value=record.value)])
                 self.gedcomx.add_place_description(place_des)
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, descriptionRef=place_des)
+                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=place_des)
                 if len(record.subRecords()) > 0:
                     self.object_map[record.level]= place_des
 
         elif isinstance(self.object_map[record.level-1], Fact):
             if self.gedcomx.places.byName(record.value):
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, descriptionRef=self.gedcomx.places.byName(record.value)[0])
+                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=self.gedcomx.places.byName(record.value)[0])
             else:
                 place_des = PlaceDescription(names=[TextValue(value=record.value)])
                 self.gedcomx.add_place_description(place_des)
-                self.object_map[record.level-1].place = PlaceReference(original=record.value, descriptionRef=place_des)
+                self.object_map[record.level-1].place = PlaceReference(original=record.value, description=place_des)
         elif isinstance(self.object_map[record.level-1], SourceDescription):
             gxobject = Note(text='Place: ' + record.value)
             self.object_map[record.level-1].add_note(gxobject)

gedcomx/Gender.py

@@ -9,6 +9,7 @@ from gedcomx.Resource import Resource
 
 from .Conclusion import Conclusion
 from .Qualifier import Qualifier
+from .Serialization import Serialization
 
 from collections.abc import Sized
 
@@ -47,55 +48,20 @@ class Gender(Conclusion):
     
     @property
     def _as_dict_(self):
-        def _serialize(value):
-            if isinstance(value, (str, int, float, bool, type(None))):
-                return value
-            elif isinstance(value, dict):
-                return {k: _serialize(v) for k, v in value.items()}
-            elif isinstance(value, (list, tuple, set)):
-                return [_serialize(v) for v in value]
-            elif hasattr(value, "_as_dict_"):
-                return value._as_dict_
-            else:
-                return str(value)  # fallback for unknown objects
+        
             
-        gender_fields = super()._as_dict_  # Start with base class fields
+        type_as_dict = super()._as_dict_  # Start with base class fields
         # Only add Relationship-specific fields
-        gender_fields.update({
+        type_as_dict.update({
             'type':self.type.value if self.type else None
                            
         })
         
-        # Serialize and exclude None values
-        for key, value in gender_fields.items():
-            if value is not None:
-                gender_fields[key] = _serialize(value)
-
-        return {
-            k: v
-            for k, v in gender_fields.items()
-            if v is not None and not (isinstance(v, Sized) and len(v) == 0)
-        }
-        
-        return gender_fields
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls,data):
-        id = data.get('id') if data.get('id') else None
-        lang = data.get('lang',None)
-        sources = [SourceReference._from_json_(o)   for o in data.get('sources')] if data.get('sources') else None
-        analysis = None #URI.from_url(data.get('analysis')) if data.get('analysis',None) else None,
-        notes = [Note._from_json_(o) for o in data.get('notes',[])]
-        #TODO confidence = ConfidenceLevel(data.get('confidence')),
-        attribution = Attribution._from_json_(data.get('attribution')) 
-        type = GenderType(data.get('type'))
         
+        return Serialization.deserialize(data, Gender)
         
-        return Gender(id=id,
-                      lang=lang,
-                      sources=sources,
-                      analysis=analysis,
-                      notes=notes,
-                      attribution=attribution,
-                      type=type)
         

gedcomx/Identifier.py

@@ -3,36 +3,40 @@ from enum import Enum
 
 from typing import List, Optional, Dict, Any
 
-from .Qualifier import Qualifier
+from collections.abc import Iterator
+import json
 from .Resource import Resource
 from .URI import URI
-
-class IdentifierType(Enum):
-    Primary = "http://gedcomx.org/Primary"
-    Authority = "http://gedcomx.org/Authority"
-    Deprecated = "http://gedcomx.org/Deprecated"
-    Persistant = "http://gedcomx.org/Persistent"
-    External = "https://gedcom.io/terms/v7/EXID"
-    Other = "user provided"
-    
-    @property
-    def description(self):
-        descriptions = {
-            IdentifierType.Primary: (
-                "The primary identifier for the resource. The value of the identifier MUST resolve to the instance of "
-                "Subject to which the identifier applies."
-            ),
-            IdentifierType.Authority: (
-                "An identifier for the resource in an external authority or other expert system. The value of the identifier "
-                "MUST resolve to a public, authoritative source for information about the Subject to which the identifier applies."
-            ),
-            IdentifierType.Deprecated: (
-                "An identifier that has been relegated, deprecated, or otherwise downgraded. This identifier is commonly used "
-                "as the result of a merge when what was once a primary identifier for a resource is no longer the primary identifier. "
-                "The value of the identifier MUST resolve to the instance of Subject to which the identifier applies."
-            )
-        }
-        return descriptions.get(self, "No description available.")
+from .Extensible.extensibles import ExtensibleEnum
+
+import secrets
+import string
+import json
+
+def make_uid(length: int = 10, alphabet: str = string.ascii_letters + string.digits) -> str:
+    """
+    Generate a cryptographically secure alphanumeric UID.
+
+    Args:
+        length: Number of characters to generate (must be > 0).
+        alphabet: Characters to choose from (default: A-Za-z0-9).
+
+    Returns:
+        A random string of `length` characters from `alphabet`.
+    """
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+class IdentifierType(ExtensibleEnum):
+    """Enumeration of identifier types."""
+    pass
+IdentifierType.register("Primary", "http://gedcomx.org/Primary")
+IdentifierType.register("Authority", "http://gedcomx.org/Authority")            
+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")
     
 class Identifier:
     identifier = 'http://gedcomx.org/v1/Identifier'
@@ -40,36 +44,20 @@ class Identifier:
 
     def __init__(self, value: Optional[List[URI]], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
         if not isinstance(value,list):
-            value = [value]
+            value = [value] if value else []
         self.type = type
         self.values = value if value else []
     
     @property
     def _as_dict_(self):
-        def _serialize(value):
-            if isinstance(value, (str, int, float, bool, type(None))):
-                return value
-            elif isinstance(value, dict):
-                return {k: _serialize(v) for k, v in value.items()}
-            elif isinstance(value, (list, tuple, set)):
-                return [_serialize(v) for v in value]
-            elif hasattr(value, "_as_dict_"):
-                return value._as_dict_
-            else:
-                return str(value)  # fallback for unknown objects
-
-        identifier_fields = {
-            'value': self.values if self.values else None,
+        from .Serialization import Serialization
+        type_as_dict = {
+            'value': [v for v in self.values] if self.values else None,
             'type': self.type.value if self.type else None
                            
         }
 
-        # Serialize and exclude None values
-        for key, value in identifier_fields.items():
-            if value is not None:
-                identifier_fields[key] = _serialize(value)
-
-        return identifier_fields
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'Identifier | None':
@@ -79,8 +67,8 @@ class Identifier:
         #for name, member in IdentifierType.__members__.items():
         #    print(name)
 
-        # Parse value (URI dict or string)
-        print('--------------',data)
+        
+        
         for key in data.keys():
             type = key
             value = data[key]
@@ -94,24 +82,25 @@ class Identifier:
         id_type: Optional[IdentifierType] = IdentifierType(raw_type) if raw_type else None
         return cls(value=value, type=id_type)
 
-class IdentifierList():
+class IdentifierList:
     def __init__(self) -> None:
-        self.identifiers = {}
-    
+        # maps identifier-type (e.g., str or IdentifierType.value) -> list of values
+        self.identifiers: dict[str, list] = {}
+
+    # -------------------- hashing/uniqueness helpers --------------------
     def make_hashable(self, obj):
         """Convert any object into a hashable representation."""
         if isinstance(obj, dict):
-            # Convert dict to sorted tuple of key/value pairs
             return tuple(sorted((k, self.make_hashable(v)) for k, v in obj.items()))
         elif isinstance(obj, (list, set, tuple)):
-            # Convert sequences/sets into tuples
             return tuple(self.make_hashable(i) for i in obj)
-        elif hasattr(obj,'_as_dict_'):
-            as_dict = obj._as_dict_
-            t = tuple(sorted((k, self.make_hashable(v)) for k, v in as_dict.items()))
-            return t
+        elif isinstance(obj, URI):
+            return obj._as_dict_
+        elif hasattr(obj, "_as_dict_"):
+            d = getattr(obj, "_as_dict_")
+            return tuple(sorted((k, self.make_hashable(v)) for k, v in d.items()))
         else:
-            return obj  # Immutable stays as is
+            return obj
 
     def unique_list(self, items):
         """Return a list without duplicates, preserving order."""
@@ -123,48 +112,113 @@ class IdentifierList():
                 seen.add(h)
                 result.append(item)
         return result
-    
-    def append(self, identifier: Identifier):
-        if isinstance(identifier, Identifier): 
-            self.add_identifer(identifier)
+
+    # -------------------- public mutation API --------------------
+    def append(self, identifier: "Identifier"):
+        if isinstance(identifier, Identifier):
+            self.add_identifier(identifier)
         else:
-            raise ValueError()
-
-    def add_identifer(self, identifier: Identifier):
-        if identifier and isinstance(identifier,Identifier):
-            if identifier.type.value in self.identifiers.keys():
-                self.identifiers[identifier.type.value].extend(identifier.values)
-            else:
-                self.identifiers[identifier.type.value] = identifier.values
-            print(self.identifiers[identifier.type.value])
-            self.identifiers[identifier.type.value] = self.unique_list(self.identifiers[identifier.type.value])
-        
-    # TODO Merge Identifiers
-    def contains(self,identifier: Identifier):
-        if identifier and isinstance(identifier,Identifier):
-            if identifier.type.value in self.identifiers.keys():
-                pass
+            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.")
+
+        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))
+        self.identifiers[key] = merged
+
+    # -------------------- queries --------------------
+    def contains(self, identifier: "Identifier") -> bool:
+        """Return True if any of the identifier's values are present under that type."""
+        if not (identifier and isinstance(identifier, Identifier) and identifier.type):
+            return False
+        key = identifier.type.value if hasattr(identifier.type, "value") else str(identifier.type)
+        if key not in self.identifiers:
+            return False
+        pool = self.identifiers[key]
+        # treat values as a list on the incoming Identifier
+        for v in getattr(identifier, "values", []):
+            if any(self.make_hashable(v) == self.make_hashable(p) for p in pool):
+                return True
+        return False
+
+    # -------------------- mapping-like dunder methods --------------------
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over identifier *types* (keys)."""
+        return iter(self.identifiers)
+
+    def __len__(self) -> int:
+        """Number of identifier types (keys)."""
+        return len(self.identifiers)
+
+    def __contains__(self, key) -> bool:
+        """Check if a type key exists (accepts str or enum with .value)."""
+        k = key.value if hasattr(key, "value") else str(key)
+        return k in self.identifiers
+
+    def __getitem__(self, key):
+        """Lookup values by type key (accepts str or enum with .value)."""
+        k = key.value if hasattr(key, "value") else str(key)
+        return self.identifiers[k]
+
+    # (optional) enable assignment via mapping syntax
+    def __setitem__(self, key, values):
+        """Set/replace the list of values for a type key."""
+        k = key.value if hasattr(key, "value") else str(key)
+        vals = values if isinstance(values, list) else [values]
+        self.identifiers[k] = self.unique_list(vals)
+
+    def __delitem__(self, key):
+        k = key.value if hasattr(key, "value") else str(key)
+        del self.identifiers[k]
+
+    # -------------------- dict-style convenience --------------------
+    def keys(self):
+        return self.identifiers.keys()
+
+    def values(self):
+        return self.identifiers.values()
+
+    def items(self):
+        return self.identifiers.items()
+
+    def iter_pairs(self) -> Iterator[tuple[str, object]]:
+        """Flattened iterator over (type_key, value) pairs."""
+        for k, vals in self.identifiers.items():
+            for v in vals:
+                yield (k, v)
     
-    def __get_item__(self):
-        pass
-
     @classmethod
-    def _from_json_(cls,data):
-        identifier_list = IdentifierList()
-        for name, member in IdentifierType.__members__.items():
-            values = data.get(member.value,None)
-            if values:
-                identifier_list.add_identifer(Identifier(values,IdentifierType(member.value)))
-        return identifier_list
-    
+    def _from_json_(cls, data):
+        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]
+                identifier_list.add_identifier(
+                    Identifier(value=vals, type=IdentifierType(key))
+                )
+            return identifier_list
+        else:
+            raise ValueError("Data must be a dict of identifiers.")
+
     @property
     def _as_dict_(self):
-        identifiers_dict = {}
-        for key in self.identifiers.keys():
-            # Should always be flat due to unique_list in add method.
-            identifiers_dict[key] = [u.value for u in self.identifiers[key]]
+        # If you want a *copy*, return `dict(self.identifiers)`
+        return self.identifiers
+
+    def __repr__(self) -> str:
+        return json.dumps(self._as_dict_, indent=4)
 
-        return identifiers_dict
+    def __str__(self) -> str:
+        return json.dumps(self._as_dict_)