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

gedcomx/Relationship.py

@@ -8,9 +8,9 @@ from .Fact import Fact
 from .Identifier import Identifier
 from .Note import Note
 from .Person import Person
-from .Serialization import serialize_to_dict
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 from .Subject import Subject
 
@@ -27,14 +27,27 @@ class RelationshipType(Enum):
         return descriptions.get(self, "No description available.")
     
 class Relationship(Subject):
+    """Represents a relationship between two Person(s)
+
+    Args:
+        type (RelationshipType): Type of relationship 
+        person1 (Person) = First Person in Relationship
+        person2 (Person): Second Person in Relationship
+
+    Raises:
+        
+    """
     identifier = 'http://gedcomx.org/v1/Relationship'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, 
+    def __init__(self,
+             person1: Optional[Person | Resource] = None,
+             person2: Optional[Person | Resource] = None,
+             facts: Optional[List[Fact]] = None,  
              id: Optional[str] = None,
              lang: Optional[str] = None,
              sources: Optional[List[SourceReference]] = None,
-             analysis: Optional[URI] = None,
+             analysis: Optional[Resource] = None,
              notes: Optional[List[Note]] = None,
              confidence: Optional[ConfidenceLevel] = None,
              attribution: Optional[Attribution] = None,
@@ -43,74 +56,40 @@ class Relationship(Subject):
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[List[Identifier]] = None,
              type: Optional[RelationshipType] = None,
-             person1: Optional[URI] = None,
-             person2: Optional[URI] = None,
-             facts: Optional[List[Fact]] = None) -> None:
+             ) -> None:
     
         # Call superclass initializer if required
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
         
-        # Initialize optional parameters with default empty lists if None
-        #self.sources = sources if sources is not None else []
-        #self.notes = notes if notes is not None else []
-        #self.evidence = evidence if evidence is not None else []
-        #self.media = media if media is not None else []
-        #self.identifiers = identifiers if identifiers is not None else []
-        #self.facts = facts if facts is not None else []
-
-        # Initialize other attributes
         self.type = type
         self.person1 = person1
         self.person2 = person2
-        self.facts = facts if facts else None
+        self.facts = facts if facts else []
     
+    def add_fact(self,fact: Fact):
+        if fact is not None and isinstance(fact,Fact):
+            for existing_fact in self.facts:
+                if fact == existing_fact:
+                    return
+            self.facts.append(fact)
+        else:
+            raise TypeError(f"Expected type 'Fact' recieved type {type(fact)}")
+
     @property
     def _as_dict_(self):
-        return serialize_to_dict(self, {
+        type_as_dict = super()._as_dict_
+        type_as_dict.update({
             "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
-            "person1": self.person1._uri,
-            "person2": self.person2._uri,
+            "person1": self.person1._as_dict_ if self.person1 else None,
+            "person2": self.person2._as_dict_ if self.person2 else None,
             "facts": [fact for fact in self.facts] if self.facts else None
         })
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: dict):
         """
-        Create a Relationship instance from a JSON-dict (already parsed).
+        Create a Person instance from a JSON-dict (already parsed).
         """
-        def ensure_list(value):
-            if value is None:
-                return []
-            if isinstance(value, list):
-                return value
-            return [value]  # wrap single item in list
-
-        # Basic scalar fields (adjust as needed)
-        id_        = data.get('id')
-        type_      = data.get('type')
-        extracted  = data.get('extracted', None)
-        private    = data.get('private', None)
-
-        # Complex singletons (adjust as needed)
-        person1    = URI.from_url(data.get('person1')['resource']) if data.get('person1') else None
-        person2    = URI.from_url(data.get('person2')['resource']) if data.get('person2') else None
-        facts      = [Fact._from_json_(o) for o in ensure_list(data.get('facts'))]
-        sources    = [SourceReference._from_json_(o) for o in ensure_list(data.get('sources'))]
-        notes      = [Note._from_json_(o) for o in ensure_list(data.get('notes'))]
-
-        # Build the instance
-        inst = cls(
-            id        = id_,
-            type      = type_,
-            extracted = extracted,
-            #private   = private,       #TODO Has this been added?
-            person1   = person1,
-            person2   = person2,
-            facts     = facts,
-            sources   = sources,
-            notes     = notes
-        )
-
-        return inst
-
+        return Serialization.deserialize(data, Relationship)
     

gedcomx/Resource.py

@@ -0,0 +1,75 @@
+from typing import List, Optional
+
+
+from .URI import URI
+    
+class Resource:
+    """
+    Class used to track and resolve URIs and references between datastores.
+
+    Parameters
+    ----------
+    
+    Raises
+    ------
+    ValueError
+        If `id` is not a valid UUID.
+    """
+    def __init__(self,uri: Optional[URI|str] = None, id:Optional[str] = None,top_lvl_object: Optional[object] = None,target= None) -> None:
+        
+        self.resource = URI.from_url(uri.value) if isinstance(uri,URI) else URI.from_url(uri) if isinstance(uri,str) else None
+        self.Id = id
+
+        self.type = None
+        self.resolved = False
+        self.target: object = target
+        self.remote: bool | None = None    # is the resource pointed to persitent on a remote datastore?
+
+        if target:
+            self.resource = target._uri
+            self.Id = target.id
+            self.type = type(target)
+   
+    @property
+    def _as_dict_(self):
+        from .Serialization import Serialization
+        typ_as_dict = {'resource':self.resource.value if self.resource else None,
+                'resourceId':self.Id}
+        return Serialization.serialize_dict(typ_as_dict)
+    
+    @classmethod
+    def _from_json_(cls,data):
+        # TODO This is not used but taken care of in Serialization
+        r = Resource(uri=data.get('resource'),id=data.get('resourceId',None))
+        #return r
+
+    def __repr__(self) -> str:
+        return f"Resource(uri={self.resource}, id={self.Id}, target={self.target})"
+    
+    def __str__(self) -> str:
+        return f"{self.resource}{f', id={self.Id}' if self.Id else ''}"
+    
+def get_resource_as_dict(value):
+    """
+    If value is truthy:
+      - If it's already a Resource, return it.
+      - Otherwise, wrap it in Resource using (value._uri, value.id).
+    Returns None if value is falsy.
+    """
+    
+    if not value:
+        return None
+
+    if isinstance(value, Resource):
+        return value._as_dict_
+    
+    try:
+        return Resource(
+            getattr(value, "uri", None),
+            getattr(value, "id", None)
+        )._as_dict_
+    except AttributeError:
+        print('get_resource_as_dict',type(value),value)
+        print((f"value: {value} as inproper attributes"))
+        exit()
+

gedcomx/Serialization.py

@@ -1,37 +1,401 @@
 from typing import Dict
 
+from .Logging import get_logger
+
+log = get_logger(__name__)
+log.setLevel("DEBUG")
+log.info("Logger initialized.")
+
+from collections.abc import Sized
+from typing import Any, get_origin, get_args, List, Set, Tuple, Dict, Union, ForwardRef, Annotated
+import types
+
+import enum
+from .Resource import Resource
+from .Identifier import IdentifierList
+from .URI import URI
+
+_PRIMITIVES = (str, int, float, bool, type(None))
 
 def _has_parent_class(obj) -> bool:
     return hasattr(obj, '__class__') and hasattr(obj.__class__, '__bases__') and len(obj.__class__.__bases__) > 0
 
-def serialize_to_dict(obj,class_values:Dict,ignore_null=True):
-    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
-
-    values_dict = {}
-    if _has_parent_class(obj):
-        values_dict.update(super(obj.__class__, obj)._as_dict_)
-    if class_values:
-        values_dict.update(class_values)
-        # Serialize and exclude None values
-
-    empty_fields = []
-    for key, value in values_dict.items():
-        if value is not None:
-            values_dict[key] = _serialize(value)
+
+class Serialization:
+
+    @staticmethod
+    def serialize_dict(dict_to_serialize: dict) -> dict:
+        """
+        Iterates through the dict, serilaizing all Gedcom Types into a json compatible value
+        
+        Parameters
+        ----------
+        dict_to_serialize: dict
+            dict that has been created from any Gedcom Type Object's _as_dict_ property
+
+        Raises
+        ------
+        ValueError
+            If `id` is not a valid UUID.
+        """
+        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
+        
+        if dict_to_serialize and isinstance(dict_to_serialize,dict):
+            for key, value in dict_to_serialize.items():
+                if value is not None:
+                    dict_to_serialize[key] = _serialize(value)
+        
+            return {
+                    k: v
+                    for k, v in dict_to_serialize.items()
+                    if v is not None and not (isinstance(v, Sized) and len(v) == 0)
+                }
+        return {}
+   
+    @staticmethod
+    def _coerce_value(value: Any, typ: Any) -> Any:
+        """Coerce `value` to `typ`:
+        - primitives: pass through
+        - containers: recurse into elements
+        - objects: call typ._from_json_(dict) if available and value is dict
+        - already-instantiated objects of typ: pass through
+        - otherwise: return value unchanged
+        """
+        def is_enum_type(T) -> bool:
+            """Return True if T (possibly a typing construct) is or contains an Enum type."""
+            origin = get_origin(T)
+
+            # Unwrap Union/Optional/PEP 604 (A | B)
+            if origin in (Union, types.UnionType):
+                return any(is_enum_type(a) for a in get_args(T))
+
+            # Unwrap Annotated[T, ...]
+            if origin is Annotated:
+                return is_enum_type(get_args(T)[0])
+
+            # Resolve forward refs / strings if you use them
+            if isinstance(T, ForwardRef):
+                T = globals().get(T.__forward_arg__, T)
+            if isinstance(T, str):
+                T = globals().get(T, T)
+
+            # Finally check enum-ness
+            try:
+                return issubclass(T, enum.Enum)
+            except TypeError:
+                return False  # not a class (e.g., typing.List[int], etc.)
+        log.debug(f"Coercing value '{value}' of type '{type(value).__name__}' to '{typ}'")
+
+        def _resolve(t):
+            # resolve ForwardRef('Resource') -> actual object if already in globals()
+            if isinstance(t, ForwardRef):
+                return globals().get(t.__forward_arg__, t)
+            return t
+
+        if is_enum_type(typ):
+            log.debug(f"Enum type detected: {typ}")
+            return typ(value)  # cast to enum
+        
+        origin = get_origin(typ)
+        if origin in (Union, types.UnionType):
+            args = tuple(_resolve(a) for a in get_args(typ))
         else:
-            empty_fields.append(key)
-    
-    for key in empty_fields:
-            del values_dict[key]
-                
-    return values_dict
+            args = (_resolve(typ),)
+        log.debug(f"Origin: {origin}, args: {args}")
+        
+        if Resource in args and isinstance(value, dict):
+            if Resource in args:
+                log.info(f"Deserializing Resource from value: {value}")
+                return Resource(uri=value.get('resource'), id=value.get('resourceId', None))
+
+        if isinstance(value, _PRIMITIVES):
+            if Resource in args:
+                log.info(f"Deserializing Resource from value: {value}")
+                return Resource(uri=value)
+            if URI in args:
+                log.info(f"Deserializing URI from value: {value}")
+                return URI.from_url(value)
+            return value
+        
+        if IdentifierList in args:
+                log.error(f"Deserializing IdentifierList from value: {value}")
+                return IdentifierList._from_json_(value)
+  
+        if origin in (list, List):
+            elem_args = get_args(typ)          # NOT get_args(args)
+            elem_t = elem_args[0] if elem_args else Any
+            log.debug(f"List: {typ}, elem={elem_t}")
+            return [Serialization._coerce_value(v, elem_t) for v in (value or [])]
+
+        if origin in (set, Set):
+            (elem_t,) = args or (Any,)
+            return { Serialization._coerce_value(v, elem_t) for v in (value or []) }
+
+        if origin in (tuple, Tuple):
+            if not args:
+                return tuple(value)
+            if len(args) == 2 and args[1] is Ellipsis:  # Tuple[T, ...]
+                elem_t = args[0]
+                return tuple(Serialization._coerce_value(v, elem_t) for v in (value or []))
+            return tuple(Serialization._coerce_value(v, t) for v, t in zip(value, args))
+
+        if origin in (dict, Dict):
+            k_t, v_t = args or (Any, Any)
+            return {
+                Serialization._coerce_value(k, k_t): Serialization._coerce_value(v, v_t)
+                for k, v in (value or {}).items()
+            }
+
+        # If `typ` has _from_json_ and value is a dict, use it
+        if hasattr(typ, "_from_json_") and isinstance(value, dict):
+            log.info(f"Deserializing {typ} from json method with value: {value}")
+            return typ._from_json_(value)
+
+        # If already the right type, keep it
+        try:
+            if isinstance(value, typ):
+                return value
+        except TypeError:
+            log.debug(f"Could not coerce value '{value}' to type '{typ}'")
+            pass  # `typ` may be a typing construct not valid for isinstance
+
+        # Fallback: leave as-is
+        log.debug(f"Returning '{type(value)}' type")
+        return value
+
+    @staticmethod
+    def get_class_fields(cls_name) -> Dict:
+        from typing import List, Optional
+        from gedcomx.Attribution import Attribution
+        from gedcomx.Document import Document  , DocumentType, TextType 
+        from gedcomx.Note import Note
+        from gedcomx.Resource import Resource
+        from gedcomx.SourceReference import SourceReference
+        from gedcomx.extensions.rs10.rsLink import _rsLinkList
+        from gedcomx.Conclusion import ConfidenceLevel
+        from gedcomx.EvidenceReference import EvidenceReference
+        from gedcomx.Identifier import IdentifierList
+        from gedcomx.Gender import  Gender, GenderType
+        from gedcomx.Fact import Fact
+        from gedcomx.Name import Name  
+        from gedcomx.URI import URI
+        from gedcomx.Qualifier import Qualifier 
+        from gedcomx.PlaceDescription import PlaceDescription
+        from gedcomx.PlaceReference import PlaceReference   
+        from gedcomx.Person import Person
+        from gedcomx.Relationship import Relationship, RelationshipType
+        from gedcomx.Identifier import Identifier   
+        from gedcomx.Date import Date
+        from gedcomx.TextValue import TextValue
+        from gedcomx.Address import Address
+        from gedcomx.OnlineAccount import OnlineAccount
+        from gedcomx.Event import Event, EventType, EventRole
+        from .SourceDescription import SourceDescription
+
+        fields = { 'Conclusion' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List["SourceReference"],
+                                    "analysis": Document | Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "uri": "Resource",
+                                    "max_note_count": int,
+                                    "links": _rsLinkList
+                                    },
+                    'Subject' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List["SourceReference"],
+                                    "analysis": Resource,
+                                    "notes": List["Note"],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "uri": Resource,
+                                    "links": _rsLinkList
+                                },
+                    'Person' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "private": bool,
+                                    "gender": Gender,
+                                    "names": List[Name],
+                                    "facts": List[Fact],
+                                    "living": bool,
+                                    "links": _rsLinkList,
+                                    'uri': Resource
+                                },
+                    'SourceReference' : {
+                                    "description": SourceDescription | URI | Resource,
+                                    "descriptionId": str,
+                                    "attribution": Attribution,
+                                    "qualifiers": List[Qualifier],
+},
+                    'Attribution' : {
+                                    "contributor": Resource | Attribution,
+                                    "modified": str,
+                                    "changeMessage": str,
+                                    "creator": Resource | Attribution,
+                                    "created": str  
+        },
+                    'Gender' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "type": GenderType,
+                                                    },
+                    'PlaceReference' : {
+                                    "original": str,
+                                    "description": PlaceDescription | URI,
+                                    },
+                    'Relationship' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Document | Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "type": RelationshipType,
+                                    "person1": Person | Resource,
+                                    "person2": Person | Resource,
+                                    "facts": List[Fact],
+},
+                    'Document' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "type": DocumentType,
+                                    "extracted": bool,
+                                    "textType": TextType,
+                                    "text": str,
+                                },
+                    'PlaceDescription' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": List[IdentifierList],
+                                    "names": List[TextValue],
+                                    "type": str,
+                                    "place": URI,
+                                    "jurisdiction": Resource | PlaceDescription,
+                                    "latitude": float,
+                                    "longitude": float,
+                                    "temporalDescription": Date,
+                                    "spatialDescription": Resource,
+                                },
+                    "Agent" : {
+    "id": str,
+    "identifiers": IdentifierList,
+    "names": List[TextValue],
+    "homepage": URI,
+    "openid": URI,
+    "accounts": List[OnlineAccount],
+    "emails": List[URI],
+    "phones": List[URI],
+    "addresses": List[Address],
+    "person": object | Resource,  # intended to be Person | Resource
+    # "xnotes": List[Note],  # commented out in your __init__
+    "attribution": object,  # for GEDCOM5/7 compatibility
+    "uri": URI | Resource,
+},
+'Event' : {
+    "id": str,
+    "lang": str,
+    "sources": List[SourceReference],
+    "analysis": Resource,
+    "notes": List[Note],
+    "confidence": ConfidenceLevel,
+    "attribution": Attribution,
+    "extracted": bool,
+    "evidence": List[EvidenceReference],
+    "media": List[SourceReference],
+    "identifiers": List[Identifier],
+    "type": EventType,
+    "date": Date,
+    "place": PlaceReference,
+    "roles": List[EventRole],
+}
+
+}
+        
+        
+        return fields[cls_name] if cls_name in fields else {}
+
+    @staticmethod
+    def deserialize(data: dict[str, Any], class_type) -> Any:
+        """
+        Deserialize `data` according to `fields` (field -> type).
+        - Primitives are assigned directly.
+        - Objects use `type._from_json_(dict)` when present.
+        - Lists/Sets/Tuples/Dicts are recursively processed.
+        Returns (result, unknown_keys).
+        """
+        log.debug(f"Deserializing '{data}' into '{class_type.__name__}'")
+        class_fields = Serialization.get_class_fields(str(class_type.__name__))
+        if class_fields == {}:
+            log.warning(f"No class fields found for '{class_type.__name__}'")
+        log.debug(f"class fields: {class_fields}")
+        result: dict[str, Any] = {}
+        known = set(class_fields.keys())
+        log.debug(f"keys found in JSON: {data.keys()}")
+        #log.debug(f"known fields: {known}")
+        for name, typ in class_fields.items():
+            if name in data:
+                log.debug(f"Field '{name}' of {class_type.__name__} found in data")
+                result[name] = Serialization._coerce_value(data[name], typ)
+                #if type(result[name]) != class_fields[name]:# TODO Write better type checking 
+                #    log.error(f"Field '{name}' of {class_type.__name__} was expected to be of type '{class_fields[name]}', but got '{type(result[name])}' with value '{result[name]}'")
+                #    raise TypeError(f"Field '{name}' expected type '{class_fields[name]}', got '{type(result[name])}'")
+                log.debug(f"Field '{name}' of '{class_type.__name__}' resulted in a '{type(result[name]).__name__}' with value '{result[name]}'")
+            else:
+                log.debug(f"Field '{name}' of '{class_type.__name__}' not found in JSON data")
+
+        unknown_keys = [k for k in data.keys() if k not in known]
+        log.info(f"Creating instance of {class_type.__name__} with fields: {result.keys()}")
+        new_cls = class_type(**result)
+        log.debug(f"Deserialized {class_type.__name__} with unknown keys: {unknown_keys}")
+        return new_cls  # type: ignore, unknown_keys

gedcomx/SourceCitation.py

@@ -17,4 +17,9 @@ class SourceCitation:
         """
         lang = data.get('lang', 'en')
         value = data.get('value')
-        return cls(lang=lang, value=value)
+        return cls(lang=lang, value=value)
+    
+    @property
+    def _as_dict_(self):
+        return {'lang':self.lang,
+                'value': self.value}