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

gedcomx/Coverage.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from .Date import Date
 from .PlaceReference import PlaceReference
-from .Serialization import Serialization
+
 
 class Coverage:
     identifier = 'http://gedcomx.org/v1/Coverage'
@@ -16,11 +16,12 @@ class Coverage:
 
     @property
     def _as_dict_(self):
-        type_as_dict = {
-            'spatial': self.spatial if self.spatial else None,
-            'temporal': self. temporal if self.temporal else None
-        }
-
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.spatial:
+            type_as_dict['spatial'] = getattr(self.spatial, '_as_dict_', self.spatial)
+        if self.temporal:  # (fixed: no space after the dot)
+            type_as_dict['temporal'] = getattr(self.temporal, '_as_dict_', self.temporal)
         return Serialization.serialize_dict(type_as_dict) 
 
     @classmethod

gedcomx/Date.py

@@ -4,6 +4,8 @@ from dateutil import parser
 import time
 
 
+
+
 class DateFormat:
     def __init__(self) -> None:
         pass
@@ -16,18 +18,23 @@ class Date:
     version = 'http://gedcomx.org/conceptual-model/v1'
 
     def __init__(self, original: Optional[str],normalized: Optional[DateNormalization] = None ,formal: Optional[str | DateFormat] = None) -> None:
-        self.orginal = original
+        self.original = original
         self.formal = formal
 
         self.normalized: DateNormalization | None = normalized if normalized else None
     
     @property
     def _as_dict_(self):
-        return {'original': self.orginal,
-                'formal': self.formal}
+        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 Serialization.serialize_dict(type_as_dict)
 
     @classmethod
-    def _from_json_(obj,data):
+    def _from_json_(cls,data):
         original = data.get('original',None)
         formal = data.get('formal',None)
         

gedcomx/Document.py

@@ -7,7 +7,7 @@ from .SourceReference import SourceReference
 from .Resource import Resource
 
 from .Conclusion import Conclusion
-from .Serialization import Serialization
+
 
 class DocumentType(Enum):
     Abstract = "http://gedcomx.org/Abstract"
@@ -53,6 +53,7 @@ class Document(Conclusion):
     
     @property
     def _as_dict(self):
+        from .Serialization import Serialization
         type_as_dict = super()._as_dict_
         if self.type:
             type_as_dict['type'] = self.type.value

gedcomx/Event.py

@@ -1,18 +1,37 @@
 from enum import Enum
 from typing import List, Optional
 
-from gedcomx.EvidenceReference import EvidenceReference
-from gedcomx.Identifier import Identifier
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    Event.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX Event Type, EventType, EventRole, EventRoleType Types
 
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: fixed mutible [] in init, replaced List[Identifer] with IdentifierList
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Type Imports
+======================================================================
+"""
 from .Attribution import Attribution
-from .Conclusion import Conclusion, ConfidenceLevel
+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 .Serialization import Serialization
+from .Resource import Resource
 from .SourceReference import SourceReference
 from .Subject import Subject
-from .Resource import Resource
+
+#=====================================================================
 
 class EventRoleType(Enum):
     Principal = "http://gedcomx.org/Principal"
@@ -23,10 +42,10 @@ class EventRoleType(Enum):
     @property
     def description(self):
         descriptions = {
-            EventRole.Principal: "The person is the principal person of the event. For example, the principal of a birth event is the person that was born.",
-            EventRole.Participant: "A participant in the event.",
-            EventRole.Official: "A person officiating the event.",
-            EventRole.Witness: "A witness of the event."
+            EventRoleType.Principal: "The person is the principal person of the event. For example, the principal of a birth event is the person that was born.",
+            EventRoleType.Participant: "A participant in the event.",
+            EventRoleType.Official: "A person officiating the event.",
+            EventRoleType.Witness: "A witness of the event."
         }
         return descriptions.get(self, "No description available.")
 
@@ -36,19 +55,64 @@ class EventRole(Conclusion):
 
     def __init__(self,
                  id: Optional[str] = None,
-                 lang: Optional[str] = 'en',
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = [],
                  analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
-                 person: Resource = None,
+                 person: Optional[Resource] = None,
                  type: Optional[EventRoleType] = None,
                  details: Optional[str] = None) -> None:
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
         self.person = person
         self.type = type
         self.details = details
+        
+    def __str__(self) -> str:
+        parts = []
+        if self.type is not None:
+            # assume enums expose .name
+            parts.append(f"type={getattr(self.type, 'name', str(self.type))}")
+        if self.person is not None:
+            # assume classes have meaningful __str__
+            parts.append(f"person={self.person}")
+        if self.details:
+            parts.append(f"details={self.details!r}")
+        if getattr(self, "id", None):
+            parts.append(f"id={self.id!r}")
+        return f"EventRole({', '.join(parts)})" if parts else "EventRole()"
+
+    def __repr__(self) -> str:
+        # assume enums expose .name and .value
+        if self.type is not None:
+            tcls = self.type.__class__.__name__
+            tname = getattr(self.type, "name", str(self.type))
+            tval = getattr(self.type, "value", self.type)
+            type_repr = f"<{tcls}.{tname}: {tval!r}>"
+        else:
+            type_repr = "None"
+        return (
+            f"{self.__class__.__name__}("
+            f"id={getattr(self, 'id', None)!r}, "
+            f"lang={getattr(self, 'lang', None)!r}, "
+            f"type={type_repr}, "
+            f"person={self.person!r}, "
+            f"details={self.details!r})"
+        )
+    
+    @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_
+        if self.type is not None:
+            type_as_dict['type'] = getattr(self.type, 'value', self.type)
+        if self.details:
+            type_as_dict['details'] = self.details
+
+        return Serialization.serialize_dict(type_as_dict)
 
 class EventType(Enum):
     Adoption = "http://gedcomx.org/Adoption"
@@ -180,16 +244,17 @@ class Event(Subject):
 
     def __init__(self,
                  id: Optional[str] = None,
-                 lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
+                 lang: Optional[str] = None,
+                 sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource] = None,
-                 notes: Optional[List[Note]] = [],
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  extracted: Optional[bool] = False,
-                 evidence: Optional[List[EvidenceReference]] = [],
-                 media: Optional[List[SourceReference]] = [],
-                 identifiers: Optional[List[Identifier]] = [],
+                 evidence: Optional[List[EvidenceReference]] = None,
+                 media: Optional[List[SourceReference]] = None,
+                 #identifiers: Optional[List[Identifier]] = [],
+                 identifiers: Optional[IdentifierList] = None,
                  type: Optional[EventType] = None,
                  date: Optional[Date] = None,
                  place: Optional[PlaceReference] = None,
@@ -203,12 +268,22 @@ class Event(Subject):
     
     @property
     def _as_dict_(self):
-        raise NotImplementedError("Not implemented yet")
+        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)
     
     @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')
-        return Serialization.deserialize(data, type_as_dict)
+        #type_as_dict = Serialization.get_class_fields('Event')
+        from .Serialization import Serialization
+        return Serialization.deserialize(data, Event)

gedcomx/ExtensibleEnum.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, Literal
+
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    ExtensibleEnum.py
+ Author:  David J. Cartwright
+ Purpose: Create a class that can act like an enum but be extended by the user at runtime.
+
+ Created: 2025-08-25
+ Updated:
+   - YYYY-MM-DD: <change description>
+   
+======================================================================
+"""
+
+@dataclass(frozen=True, slots=True)
+class _EnumItem:
+    """
+    A single registered member of an :class:`ExtensibleEnum`.
+
+    Each `_EnumItem` represents one (name, value) pair that belongs
+    to a particular `ExtensibleEnum` subclass. Items are immutable
+    once created.
+
+    Attributes
+    ----------
+    owner : type
+        The subclass of :class:`ExtensibleEnum` that owns this member
+        (e.g., `Color`).
+    name : str
+        The symbolic name of the member (e.g., `"RED"`).
+    value : Any
+        The underlying value associated with the member (e.g., `"r"`).
+
+    Notes
+    -----
+    - Equality is determined by object identity (not overridden).
+    - Instances are hashable by default since the dataclass is frozen.
+    - The `__repr__` and `__str__` provide user-friendly string forms.
+
+    Examples
+    --------
+    >>> class Color(ExtensibleEnum): ...
+    >>> red = Color.register("RED", "r")
+    >>> repr(red)
+    'Color.RED'
+    >>> str(red)
+    'RED'
+    >>> red.value
+    'r'
+    """
+    owner: type
+    name: str
+    value: Any
+    def __repr__(self) -> str:  # print(...) shows "Color.RED"
+        return f"{self.owner.__name__}.{self.name}"
+    def __str__(self) -> str:
+        return self.name
+
+class _ExtEnumMeta(type):
+    def __iter__(cls) -> Iterator[_EnumItem]:
+        return iter(cls._members.values())
+    def __contains__(cls, item: object) -> bool:
+        return item in cls._members.values()
+    # Support Color('RED') / Color(2)
+    def __call__(cls, arg: Any, /, *, by: Literal["auto","name","value"]="auto") -> _EnumItem:
+        if isinstance(arg, _EnumItem):
+            if arg.owner is cls:
+                return arg
+            raise TypeError(f"{arg!r} is not a member of {cls.__name__}")
+        if by == "name":
+            return cls.get(str(arg))
+        if by == "value":
+            return cls.from_value(arg)
+        if isinstance(arg, str) and arg in cls._members:
+            return cls.get(arg)
+        return cls.from_value(arg)
+
+class ExtensibleEnum(metaclass=_ExtEnumMeta):
+    """
+    A lightweight, **runtime-extensible**, enum-like base class.
+
+    Subclass this to create an enum whose members can be registered at runtime.
+    Registered members are exposed as class attributes (e.g., `Color.RED`) and
+    can be retrieved by name (`Color.get("RED")`) or by value
+    (`Color.from_value("r")`). Square-bracket lookup (`Color["RED"]`) is also
+    supported via ``__class_getitem__``.
+
+    This is useful when:
+      - The full set of enum values is not known until runtime (plugins, config).
+      - You need attribute-style access (`Color.RED`) but want to add members
+        dynamically and/or validate uniqueness of names/values.
+
+    Notes
+    -----
+    - **Uniqueness:** Names and values are unique within a subclass.
+    - **Per-subclass registry:** Each subclass has its own member registry.
+    - **Thread safety:** Registration is **not** thread-safe. If multiple threads
+      may register members, wrap `register()` calls in your own lock.
+    - **Immutability:** Once registered, a member’s `name` and `value` are fixed.
+      Re-registering the same `name` with the *same* `value` returns the existing
+      item; a different value raises an error.
+
+    Examples
+    --------
+    Define an extensible enum and register members:
+
+    >>> class Color(ExtensibleEnum):
+    ...     pass
+    ...
+    >>> Color.register("RED", "r")
+    _EnumItem(owner=Color, name='RED', value='r')
+    >>> Color.register("GREEN", "g")
+    _EnumItem(owner=Color, name='GREEN', value='g')
+
+    Access members:
+
+    >>> Color.RED is Color.get("RED")
+    True
+    >>> Color["GREEN"] is Color.get("GREEN")
+    True
+    >>> Color.from_value("g") is Color.GREEN
+    True
+    >>> Color.names()
+    ['RED', 'GREEN']
+
+    Error cases:
+
+    >>> Color.register("RED", "different")  # doctest: +IGNORE_EXCEPTION_DETAIL
+    ValueError: name 'RED' already used with different value 'r'
+    >>> Color.get("BLUE")                    # doctest: +IGNORE_EXCEPTION_DETAIL
+    KeyError: Color has no member named 'BLUE'
+    >>> Color.from_value("b")                # doctest: +IGNORE_EXCEPTION_DETAIL
+    KeyError: Color has no member with value 'b'
+    """
+    """Runtime-extensible enum-like base."""
+    _members: Dict[str, _EnumItem] = {}
+
+    def __init_subclass__(cls, **kw):
+        super().__init_subclass__(**kw)
+        cls._members = {}  # fresh registry per subclass
+
+    @classmethod
+    def __class_getitem__(cls, key: str) -> _EnumItem:  # Color['RED']
+        return cls.get(key)
+
+    @classmethod
+    def register(cls, name: str, value: Any) -> _EnumItem:
+        if not isinstance(name, str) or not name.isidentifier():
+            raise ValueError("name must be a valid identifier")
+        if name in cls._members:
+            item = cls._members[name]
+            if item.value != value:
+                raise ValueError(f"name {name!r} already used with different value {item.value!r}")
+            return item
+        if any(m.value == value for m in cls._members.values()):
+            raise ValueError(f"value {value!r} already used")
+        item = _EnumItem(owner=cls, name=name, value=value)
+        cls._members[name] = item
+        setattr(cls, name, item)  # enables Color.RED attribute
+        return item
+
+    @classmethod
+    def names(cls) -> list[str]:
+        return list(cls._members.keys())
+
+    @classmethod
+    def get(cls, name: str) -> _EnumItem:
+        try:
+            return cls._members[name]
+        except KeyError as e:
+            raise KeyError(f"{cls.__name__} has no member named {name!r}") from e
+
+    @classmethod
+    def from_value(cls, value: Any) -> _EnumItem:
+        for m in cls._members.values():
+            if m.value == value:
+                return m
+        raise KeyError(f"{cls.__name__} has no member with value {value!r}")
+

gedcomx/Extensions/__init__.py

@@ -0,0 +1 @@
+from .rs10 import rsLink

gedcomx/Extensions/rs10/__init__.py

@@ -0,0 +1 @@
+from .rsLink import rsLink

gedcomx/Extensions/rs10/rsLink.py

@@ -0,0 +1,116 @@
+'''
+The "Link" Data Type
+The Link data type defines a representation of an available transition from one application state to another. 
+The base definition of a link is provided by RFC 5988.
+
+Instances of Link can be reasonably expected as extension elements to any GEDCOM X data type,
+except data types that are defined by the GEDCOM X Conceptual Model to explicitly restrict extension properties.
+'''
+
+'''
+8/25/25, 0.5.5, built serialization, type checking in init for href
+'''
+
+from typing import List, Optional
+from ...URI import URI
+from ...Exceptions import GedcomClassAttributeError
+
+
+class rsLink():
+    """A link description object. RS Extension to GedcomX by FamilySearch.
+
+    Args:
+        rel (str): Link relation identifier. Required.
+        href (str, optional): Link target URI. If omitted, provide `template`.
+        template (str, optional): URI Template (see RFC 6570). If omitted, provide `href`.
+        type (str, optional): Media type(s) of the linked resource (RFC 2616 §3.7).
+        accept (str, optional): Acceptable media type(s) for updating the linked resource (RFC 2616 §3.7).
+        allow (str, optional): Allowable HTTP methods to transition to the linked resource (RFC 2616 §14.7).
+        hreflang (str, optional): Language of the linked resource (e.g., BCP-47 tag).
+        title (str, optional): Human-readable label for the link.
+
+    Raises:
+        ValueError: If neither `href` nor `template` is provided.
+    """
+
+    """Attribution Information for a Genealogy, Conclusion, Subject and child classes
+
+    Args:
+        contributor (Agent, optional):            Contributor to object being attributed.
+        modified (timestamp, optional):           timestamp for when this record was modified.
+        changeMessage (str, optional):            Birth date (YYYY-MM-DD).
+        creator (Agent, optional):      Creator of object being attributed.
+        created (timestamp, optional):            timestamp for when this record was created
+
+    Raises:
+        
+    """
+    identifier = "http://gedcomx.org/v1/Link"
+
+    def __init__(self,rel: Optional[URI] = None,
+                 href:  Optional[URI] = None,
+                 template: Optional[str] = None,
+                 type: Optional[str] = None,
+                 accept: Optional[str] = None,
+                 allow: Optional[str] = None,
+                 hreflang: Optional[str] = None,
+                 title: Optional[str] = None) -> None:
+        
+        self.rel = rel
+        self.href = href if isinstance(href,URI) else URI.from_url(href) if isinstance(href,str) else None
+        self.template = template
+        self.type = type
+        self.accept = accept
+        self.allow = allow
+        self.hreflang = hreflang
+        self.title = title
+    
+        if self.href is None and self.template is None:
+            raise GedcomClassAttributeError("href or template are required")
+    
+    @property
+    def _as_dict_(self):
+        from ...Serialization import Serialization
+        type_as_dict = {
+            "rel": self.rel._as_dict_ if self.rel else None,
+            "href": self.href._as_dict_ if self.href else None,
+            "template": self.template,   # RFC 6570 template if used
+            "type": self.type,           # media type (note: shadows built-in 'type')
+            "accept": self.accept,
+            "allow": self.allow,
+            "hreflang": self.hreflang,
+            "title": self.title,
+        }
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @property
+    def json(self):
+        import json
+        return json.dumps(self._as_dict_)
+
+class _rsLinkList():
+    def __init__(self) -> None:
+        self.links = {}
+
+    def add(self,link: rsLink):
+        if link and isinstance(link,rsLink):
+            if link.rel in self.links.keys():
+                self.links[link.rel].append(link.href)
+            else:
+                self.links[link.rel] = [link.href]
+        
+
+    @classmethod
+    def _from_json_(cls,data: dict):
+        
+        link_list = _rsLinkList()
+        for rel in data.keys():
+            link_list.add(rsLink(rel,data[rel]))
+        return link_list
+    
+    @property
+    def _as_dict_(self) -> dict:
+        return self.links
+
+
+        

gedcomx/Fact.py

@@ -12,7 +12,7 @@ from .Date import Date
 from .Note import Note
 from .PlaceReference import PlaceReference
 from .SourceReference import SourceReference
-from .Serialization import Serialization
+
 from .Resource import Resource
 
 from .Conclusion import Conclusion
@@ -367,7 +367,6 @@ class FactType(Enum):
         for word in words:
             matches = difflib.get_close_matches(word, keywords_to_fact_type.keys(), n=1, cutoff=0.8)
             if matches:
-                print(f"Guessed '{description} to be of fact type: {keywords_to_fact_type[matches[0]]}")
                 return keywords_to_fact_type[matches[0]]
         return None
 
@@ -397,7 +396,7 @@ class Fact(Conclusion):
 
     def __init__(self,
                  id: Optional[str] = None,
-                 lang: str = 'en',
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = [],
                  analysis: Optional[Resource | Document] = None,
                  notes: Optional[List[Note]] = [],
@@ -429,24 +428,28 @@ class Fact(Conclusion):
 
     @property
     def _as_dict_(self):
-        fact_dict = super()._as_dict_
+        from .Serialization import Serialization
+        type_as_dcit = super()._as_dict_
         # Only add Relationship-specific fields
-        fact_dict.update( {
-            'type': self.type.value if self.type else None,
-            'date': self.date._as_dict_ if self.date else None,
-            'place': self.place._as_dict_ if self.place else None,
-            'value': self.value,
-            'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
-        })
+        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]
         
-        return Serialization.serialize_dict(fact_dict)
+        return Serialization.serialize_dict(type_as_dcit)
     
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'Fact':
         
         # Extract fields, no trailing commas!
         id_          = data.get('id')
-        lang         = data.get('lang', 'en')
+        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)