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

gedcomx/Gender.py

@@ -5,10 +5,13 @@ from gedcomx.Attribution import Attribution
 from gedcomx.Conclusion import ConfidenceLevel
 from gedcomx.Note import Note
 from gedcomx.SourceReference import SourceReference
-from gedcomx.URI import URI
+from gedcomx.Resource import Resource
 
 from .Conclusion import Conclusion
 from .Qualifier import Qualifier
+from .Serialization import Serialization
+
+from collections.abc import Sized
 
 class GenderType(Enum):
     Male = "http://gedcomx.org/Male"
@@ -33,16 +36,32 @@ class Gender(Conclusion):
     def __init__(self,
                  id: Optional[str] = None,
                  lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
-                 notes: Optional[List[Note]] = [],
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[Resource] = None,
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None, 
-                 type: GenderType = None
+                 type: Optional[GenderType] = None
                  ) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        super().__init__(id=id, lang=lang, sources=sources, analysis=analysis, notes=notes, confidence=confidence, attribution=attribution)
         self.type = type
     
+    @property
+    def _as_dict_(self):
+        
+            
+        type_as_dict = super()._as_dict_  # Start with base class fields
+        # Only add Relationship-specific fields
+        type_as_dict.update({
+            'type':self.type.value if self.type else None
+                           
+        })
+        
+        return Serialization.serialize_dict(type_as_dict)
+
     @classmethod
-    def _from_json_(cls,json_text):
-        return Gender()
+    def _from_json_(cls,data):
+        
+        return Serialization.deserialize(data, Gender)
+        
+        

gedcomx/Group.py

@@ -9,7 +9,7 @@ from .Identifier import Identifier
 from .Note import Note
 from .PlaceReference import PlaceReference
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 from .TextValue import TextValue
 from .Subject import Subject
@@ -22,14 +22,14 @@ class GroupRole:
     identifier = 'http://gedcomx.org/v1/GroupRole'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, person: URI,type: Optional[Enum], date: Optional[Date],details: Optional[str]) -> None:
+    def __init__(self, person: Resource,type: Optional[Enum], date: Optional[Date],details: Optional[str]) -> None:
         pass
 
 class Group(Subject):
     identifier = 'http://gedcomx.org/v1/Group'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str | None, lang: str | None, sources: SourceReference | None, analysis: URI | None, notes: Note | None, confidence: ConfidenceLevel | None, attribution: Attribution | None, extracted: bool | None, evidence: List[EvidenceReference] | None, media: List[SourceReference] | None, identifiers: List[Identifier] | None,
+    def __init__(self, id: str | None, lang: str | None, sources: SourceReference | None, analysis: Resource | None, notes: Note | None, confidence: ConfidenceLevel | None, attribution: Attribution | None, extracted: bool | None, evidence: List[EvidenceReference] | None, media: List[SourceReference] | None, identifiers: List[Identifier] | None,
                  names: TextValue,
                  date: Optional[Date],
                  place: Optional[PlaceReference],

gedcomx/Identifier.py

@@ -3,87 +3,224 @@ 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
+from .Extensible.extensibles import ExtensibleEnum
 
-class IdentifierType(Enum):
-    Primary = "http://gedcomx.org/Primary"
-    Authority = "http://gedcomx.org/Authority"
-    Deprecated = "http://gedcomx.org/Deprecated"
-    Persistant = "http://gedcomx.org/Persistent"
-    
-    @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.")
+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'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, value: Optional[URI], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
-        self.value = value
+    def __init__(self, value: Optional[List[URI]], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
+        if not isinstance(value,list):
+            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.value if self.value 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':
+    def _from_json_(cls, data: Dict[str, Any]) -> 'Identifier | None':
         """
         Construct an Identifier from a dict parsed from JSON.
         """
-        # Parse value (URI dict or string)
+        #for name, member in IdentifierType.__members__.items():
+        #    print(name)
+
+        
         
         for key in data.keys():
             type = key
             value = data[key]
-        uri_obj: Optional[URI] = None
+        uri_obj: Optional[Resource] = None
         # TODO DO THIS BETTER
 
         # Parse type
         raw_type = data.get('type')
-        id_type: Optional[IdentifierType] = IdentifierType(raw_type)
-        
+        if raw_type is None:
+            return None
+        id_type: Optional[IdentifierType] = IdentifierType(raw_type) if raw_type else None
+        return cls(value=value, type=id_type)
+
+class IdentifierList:
+    def __init__(self) -> None:
+        # 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):
+            return tuple(sorted((k, self.make_hashable(v)) for k, v in obj.items()))
+        elif isinstance(obj, (list, set, tuple)):
+            return tuple(self.make_hashable(i) for i in obj)
+        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
+
+    def unique_list(self, items):
+        """Return a list without duplicates, preserving order."""
+        seen = set()
+        result = []
+        for item in items:
+            h = self.make_hashable(item)
+            if h not in seen:
+                seen.add(h)
+                result.append(item)
+        return result
+
+    # -------------------- public mutation API --------------------
+    def append(self, identifier: "Identifier"):
+        if isinstance(identifier, Identifier):
+            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.")
+
+        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)
+    
+    @classmethod
+    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):
+        # If you want a *copy*, return `dict(self.identifiers)`
+        return self.identifiers
+
+    def __repr__(self) -> str:
+        return json.dumps(self._as_dict_, indent=4)
+
+    def __str__(self) -> str:
+        return json.dumps(self._as_dict_)
+
+
+
+
 
-        return cls(value=value, type=id_type)

gedcomx/Logging.py

@@ -0,0 +1,19 @@
+import logging
+
+def get_logger(name='gedcomx.log'):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter('[%(asctime)s] %(levelname)s - %(name)s - %(message)s')
+
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        # Optional: file logging
+        file_handler = logging.FileHandler(f"{name}.log", encoding="utf-8")
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger

gedcomx/Mutations.py

@@ -0,0 +1,228 @@
+from .Gedcom5x import GedcomRecord
+from .Fact import Fact, FactType
+from .Event import Event, EventType
+
+fact_event_table = {
+    # Person Fact / Event Types
+    "ADOP": {
+        "Fact": FactType.AdoptiveParent,
+        "Event": EventType.Adoption,
+    },
+    "CHR": {
+        "Fact": FactType.AdultChristening,
+        "Event": EventType.AdultChristening,
+    },
+    "EVEN": {
+        "Fact": FactType.Amnesty,
+        # no Event
+    },
+    "BAPM": {
+        "Fact": FactType.Baptism,
+        "Event": EventType.Baptism,
+    },
+    "BARM": {
+        "Fact": FactType.BarMitzvah,
+        "Event": EventType.BarMitzvah,
+    },
+    "BASM": {
+        "Fact": FactType.BatMitzvah,
+        "Event": EventType.BatMitzvah,
+    },
+    "BIRT": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BIRT, CHR": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BLES": {
+        "Fact": FactType.Blessing,
+        "Event": EventType.Blessing,
+    },
+    "BURI": {
+        "Fact": FactType.Burial,
+        "Event": EventType.Burial,
+    },
+    "CAST": {
+        "Fact": FactType.Caste,
+        # no Event
+    },
+    "CENS": {
+        "Fact": FactType.Census,
+        "Event": EventType.Census,
+    },
+    "CIRC": {
+        "Fact": FactType.Circumcision,
+        "Event": EventType.Circumcision,
+    },
+    "CONF": {
+        "Fact": FactType.Confirmation,
+        "Event": EventType.Confirmation,
+    },
+    "CREM": {
+        "Fact": FactType.Cremation,
+        "Event": EventType.Cremation,
+    },
+    "DEAT": {
+        "Fact": FactType.Death,
+        "Event": EventType.Death,
+    },
+    "EDUC": {
+        "Fact": FactType.Education,
+        "Event": EventType.Education,
+    },
+    "EMIG": {
+        "Fact": FactType.Emigration,
+        "Event": EventType.Emigration,
+    },
+    "FCOM": {
+        "Fact": FactType.FirstCommunion,
+        "Event": EventType.FirstCommunion,
+    },
+    "GRAD": {
+        "Fact": FactType.Graduation,
+        # no Event
+    },
+    "IMMI": {
+        "Fact": FactType.Immigration,
+        "Event": EventType.Immigration,
+    },
+    "MIL": {
+        "Fact": FactType.MilitaryService,
+        # no Event
+    },
+    "NATI": {
+        "Fact": FactType.Nationality,
+        # no Event
+    },
+    "NATU": {
+        "Fact": FactType.Naturalization,
+        "Event": EventType.Naturalization,
+    },
+    "OCCU": {
+        "Fact": FactType.Occupation,
+        # no Event
+    },
+    "ORDN": {
+        "Fact": FactType.Ordination,
+        "Event": EventType.Ordination,
+    },
+    "DSCR": {
+        "Fact": FactType.PhysicalDescription,
+        # no Event
+    },
+    "PROB": {
+        "Fact": FactType.Probate,
+        # no Event
+    },
+    "PROP": {
+        "Fact": FactType.Property,
+        # no Event
+    },
+    "RELI": {
+        "Fact": FactType.Religion,
+        # no Event
+    },
+    "RESI": {
+        "Fact": FactType.Residence,
+        # no Event
+    },
+    "WILL": {
+        "Fact": FactType.Will,
+        # no Event
+    },
+
+    # Couple Relationship Fact / Event Types
+    "ANUL": {
+        "Fact": FactType.Annulment,
+        "Event": EventType.Annulment,
+    },
+    "DIV": {
+        "Fact": FactType.Divorce,
+        "Event": EventType.Divorce,
+    },
+    "DIVF": {
+        "Fact": FactType.DivorceFiling,
+        "Event": EventType.DivorceFiling,
+    },
+    "ENGA": {
+        "Fact": FactType.Engagement,
+        "Event": EventType.Engagement,
+    },
+    "MARR": {
+        "Fact": FactType.Marriage,
+        "Event": EventType.Marriage,
+    },
+    "MARB": {
+        "Fact": FactType.MarriageBanns,
+        # no Event
+    },
+    "MARC": {
+        "Fact": FactType.MarriageContract,
+        # no Event
+    },
+    "MARL": {
+        "Fact": FactType.MarriageLicense,
+        # no Event
+    },
+    "MARS":{
+        "Fact":EventType.MarriageSettlment
+
+    },
+    "SEPA": {
+        "Fact": FactType.Separation,
+        # no Event
+    },
+
+}
+
+class GedcomXObject:
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        self.created_with_tag: str = record.tag if record and isinstance(record, GedcomRecord) else None    
+        self.created_at_level: int = record.level if record and isinstance(record, GedcomRecord) else None
+        self.created_at_line_number: int = record.line_number if record and isinstance(record, GedcomRecord) else None
+
+class GedcomXSourceOrDocument(GedcomXObject):
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        super().__init__(record)
+        self.title: str = None
+        self.citation: str = None
+        self.page: str = None
+        self.contributor: str = None
+        self.publisher: str = None
+        self.rights: str = None
+        self.url: str = None
+        self.medium: str = None
+        self.type: str = None
+        self.format: str = None
+        self.created: str = None
+        self.modified: str = None
+        self.language: str = None
+        self.relation: str = None
+        self.identifier: str = None
+        self.description: str = None
+
+class GedcomXEventOrFact(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+        super().__init__(record)
+        if record.tag in fact_event_table.keys():
+
+            if 'Fact' in fact_event_table[record.tag].keys():
+                obj = Fact(type=fact_event_table[record.tag]['Fact'])
+                return obj
+            elif 'Event' in fact_event_table[record.tag].keys():
+                obj = Event(type=fact_event_table[record.tag]['Fact'])
+            else:
+                raise ValueError
+        else:
+            raise ValueError(f"{record.tag} not found in map")
+
+class GedcomXRelationshipBuilder(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | 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
+
+