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

gedcomx/SourceDescription.py

@@ -9,18 +9,23 @@ from .Agent import Agent
 from .Attribution import Attribution
 from .Coverage import Coverage
 from .Date import Date
-from .Identifier import Identifier
+from .Identifier import Identifier, IdentifierList
 from .Note import Note
 from .SourceCitation import SourceCitation
 from .SourceReference import SourceReference
 from .TextValue import TextValue
+from .Resource import Resource, get_resource_as_dict
+from .Serialization import Serialization
 from .URI import URI
 
+from collections.abc import Sized
+
 class ResourceType(Enum):
     Collection = "http://gedcomx.org/Collection"
     PhysicalArtifact = "http://gedcomx.org/PhysicalArtifact"
     DigitalArtifact = "http://gedcomx.org/DigitalArtifact"
     Record = "http://gedcomx.org/Record"
+    Person = "http://gedcomx.org/Person"    
     
     @property
     def description(self):
@@ -33,26 +38,49 @@ class ResourceType(Enum):
         return descriptions.get(self, "No description available.")
     
 class SourceDescription:
+    """
+    The SourceDescription data type defines a description of a source of genealogical information.
+    http://gedcomx.org/v1/SourceDescription
+
+    Parameters
+    ----------
+    id : str
+        Unique identifier for this SourceDescription.
+    attribution : Attribution Object
+        Attribution information for the Genealogy
+    filepath : str
+        Not Implimented.
+    description : str
+        Description of the Genealogy: ex. 'My Family Tree'
+
+    Raises
+    ------
+    ValueError
+        If `id` is not a valid UUID.
+    """
     identifier = "http://gedcomx.org/v1/SourceDescription"
+    """
+    Gedcom-X Specification Identifier
+    """
 
     def __init__(self, id: Optional[str] = None,
                  resourceType: Optional[ResourceType] = None,
                  citations: Optional[List[SourceCitation]] = [],
                  mediaType: Optional[str] = None,
                  about: Optional[URI] = None,
-                 mediator: Optional[URI] = None,
-                 publisher: Optional[URI] = None,
-                 authors: Optional[List[URI]] = [],
-                 sources: List[SourceReference] = [], # SourceReference
-                 analysis: Optional[URI] = None,  # analysis should be of type 'Document', not specified to avoid circular import
+                 mediator: Optional[Resource] = None,
+                 publisher: Optional[Resource|Agent] = None,
+                 authors: Optional[List[Resource]] = None,
+                 sources: Optional[List[SourceReference]] = None, # SourceReference
+                 analysis: Optional[Resource] = None,  # analysis should be of type 'Document', not specified to avoid circular import
                  componentOf: Optional[SourceReference] = None, # SourceReference
-                 titles: Optional[List[TextValue]] = [],
-                 notes: Optional[List[Note]] = [],
+                 titles: Optional[List[TextValue]] = None,
+                 notes: Optional[List[Note]] = None,
                  attribution: Optional[Attribution] = None,
-                 rights: Optional[List[URI]] = [],
-                 coverage: Optional[Coverage] = None, # Coverage
-                 descriptions: Optional[List[TextValue]] = [],
-                 identifiers: Optional[List[Identifier]] = [],
+                 rights: Optional[List[Resource]] = [],
+                 coverage: Optional[List[Coverage]] = None, # Coverage
+                 descriptions: Optional[List[TextValue]] = None,
+                 identifiers: Optional[IdentifierList] = None,
                  created: Optional[Date] = None,
                  modified: Optional[Date] = None,
                  published: Optional[Date] = None,
@@ -65,9 +93,9 @@ class SourceDescription:
         self.mediaType = mediaType
         self.about = about
         self.mediator = mediator
-        self.publisher = publisher
+        self._publisher = publisher 
         self.authors = authors or []
-        self.source_refs = sources or []
+        self.sources = sources or []
         self.analysis = analysis
         self.componentOf = componentOf
         self.titles = titles or []
@@ -76,14 +104,30 @@ class SourceDescription:
         self.rights = rights or []
         self.coverage = coverage or []
         self.descriptions = descriptions or []
-        self.identifiers = identifiers or []
+        self.identifiers = identifiers or IdentifierList()
         self.created = created
         self.modified = modified
         self.published = published
         self.repository = repository
         self.max_note_count = max_note_count
 
-        self._uri = URI(fragment=id)
+        self.uri = URI(fragment=id)
+    
+    @property
+    def publisher(self) -> Resource | Agent | None:
+        return self._publisher
+    
+
+    @publisher.setter
+    def publisher(self, value: Resource | Agent):
+        if value is None:
+            self._publisher = None
+        elif isinstance(value,Resource):
+            self._publisher = value
+        elif isinstance(value,Agent):
+            self._publisher = value
+        else:
+            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")
     
     def add_description(self, desccription_to_add: TextValue):
         if desccription_to_add and isinstance(desccription_to_add,TextValue):
@@ -94,9 +138,6 @@ class SourceDescription:
 
     def add_identifier(self, identifier_to_add: Identifier):
         if identifier_to_add and isinstance(identifier_to_add,Identifier):
-            for current_identifier in self.identifiers:
-                if identifier_to_add == current_identifier:
-                    return
             self.identifiers.append(identifier_to_add)
     
     def add_note(self,note_to_add: Note):
@@ -139,51 +180,37 @@ class SourceDescription:
     
     @property
     def _as_dict_(self) -> Dict[str, Any]:
-        def _serialize(val: Any) -> Any:
-            if hasattr(val, '_as_dict_'):
-                return val._as_dict_
-            if isinstance(val, URI):
-                return val._prop_dict()
-            if isinstance(val, Enum):
-                return val.value
-            if isinstance(val, (str, int, float, bool)) or val is None:
-                return val
-            if isinstance(val, list):
-                return [_serialize(v) for v in val]
-            if isinstance(val, dict):
-                return {k: _serialize(v) for k, v in val.items()}
-            return str(val)
-
-        data = {
+        type_as_dict = {
             'id': self.id,
+            'about': self.about._as_dict_ if self.about else None,
             'resourceType': self.resourceType.value if self.resourceType else None,
             'citations': [c._as_dict_ for c in self.citations] or None,
             'mediaType': self.mediaType,
-            'about': self.about._prop_dict() if self.about else None,
-            'mediator': self.mediator._prop_dict() if self.mediator else None,
-            'publisher': self.publisher._prop_dict() if self.publisher else None,
-            'authors': [a._prop_dict() for a in self.authors] or None,
+            'mediator': self.mediator._as_dict_ if self.mediator else None,
+            'publisher': self.publisher._as_dict_ if self.publisher else None,
+            'authors': self.authors and [a._as_dict_ for a in self.authors] or None,
             'sources': [s._as_dict_ for s in self.sources] or None,
-            'analysis': self.analysis._prop_dict() if self.analysis else None,
+            'analysis': self.analysis._as_dict_ if self.analysis else None,
             'componentOf': self.componentOf._as_dict_ if self.componentOf else None,
-            'titles': [t._prop_dict() for t in self.titles] or None,
-            'notes': [n._prop_dict() for n in self.notes] or None,
+            'titles': [t._as_dict_ for t in self.titles] or None,
+            'notes': [n._as_dict_ for n in self.notes] or None,
             'attribution': self.attribution._as_dict_ if self.attribution else None,
-            'rights': [r._prop_dict() for r in self.rights] or None,
-            'coverage': self.coverage._as_dict_ if self.coverage else None,
-            'descriptions': [d._prop_dict() for d in self.descriptions] or None,
-            'identifiers': [i._as_dict_ for i in self.identifiers] or None,
-            'created': self.created._prop_dict() if self.created else None,
-            'modified': self.modified._prop_dict() if self.modified else None,
-            'published': self.published._prop_dict() if self.published else None,
-            'repository': self.repository._prop_dict() if self.repository else None
+            'rights': [r._as_dict_ for r in self.rights] or None,
+            'coverage': [c._as_dict_ for c in self.coverage] or None,
+            'descriptions': [d._as_dict_ for d in self.descriptions] or None,
+            'identifiers': self.identifiers._as_dict_ if self.identifiers else None,
+            'created': self.created if self.created else None,
+            'modified': self.modified if self.modified else None,
+            'published': self.published if self.published else None,
+            'repository': self.repository._as_dict_ if self.repository else None,
+            'uri': self.uri.value
         }
-        # Remove None values
-        return {k: v for k, v in data.items() if v is not None}
-    
+        
+        return Serialization.serialize_dict(type_as_dict)
+         
+            
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'SourceDescription':
-        print(data,type(data))
         # TODO Hande Resource/URI
         
         # Basic fields
@@ -193,11 +220,11 @@ class SourceDescription:
         # Sub-objects
         citations    = [SourceCitation._from_json_(c) for c in data.get('citations', [])]
         about        = URI._from_json_(data['about']) if data.get('about') else None
-        mediator     = URI._from_json_(data['mediator']) if data.get('mediator') else None
-        publisher    = Agent._from_json_(data['publisher']) if data.get('publisher') else None
-        authors      = [URI._from_json_(a) for a in data.get('authors', [])]
+        mediator     = Resource._from_json_(data['mediator']) if data.get('mediator') else None
+        publisher    = Resource._from_json_(data['publisher']) if data.get('publisher') else None
+        authors      = [Resource._from_json_(a) for a in data.get('authors', [])]
         sources      = [SourceReference._from_json_(s) for s in data.get('sources', [])]
-        analysis     = URI._from_json_(data['analysis']) if data.get('analysis') else None
+        analysis     = Resource._from_json_(data['analysis']) if data.get('analysis') else None
         component_of = SourceReference._from_json_(data['componentOf']) if data.get('componentOf') else None
         titles       = [TextValue._from_json_(t) for t in data.get('titles', [])]
         notes        = [Note._from_json_(n) for n in data.get('notes', [])]
@@ -205,9 +232,10 @@ class SourceDescription:
         rights       = [URI._from_json_(r) for r in data.get('rights', [])]
         coverage     = [Coverage._from_json_(cvg) for cvg in data.get('coverage',[])] 
         descriptions = [TextValue._from_json_(d) for d in data.get('descriptions', [])]
-        identifiers  = [Identifier._from_json_(i) for i in data.get('identifiers', [])]
+        identifiers  = IdentifierList._from_json_(data.get('identifiers', []))
+        
         created      = Date._from_json_(data['created']) if data.get('created') else None
-        modified     = Date._from_json_(data['modified']) if data.get('modified') else None
+        modified     = data.get('modified',None)
         published    = Date._from_json_(data['published']) if data.get('published') else None
         repository   = Agent._from_json_(data['repository']) if data.get('repository') else None
 
@@ -224,18 +252,4 @@ class SourceDescription:
             published=published, repository=repository
         )
 
-    @property
-    def publisher(self) -> URI:
-        if not self._publisher is None or isinstance(self._publisher,URI): assert False
-        return self._publisher
-
-    @publisher.setter
-    def publisher(self, value: URI | Agent):
-        if value is None:
-            self._publisher = None
-        elif isinstance(value,URI):
-            assert False
-        elif isinstance(value,Agent):
-            self._publisher = value._uri
-        else:
-            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")
+    

gedcomx/SourceReference.py

@@ -3,8 +3,12 @@ from typing import List, Optional
 from .Attribution import Attribution
 from .Qualifier import Qualifier
 
+from .Resource import Resource
+from .Serialization import Serialization
 from .URI import URI
 
+from collections.abc import Sized
+
 class KnownSourceReference(Qualifier):
     CharacterRegion = "http://gedcomx.org/CharacterRegion"
     RectangleRegion = "http://gedcomx.org/RectangleRegion"
@@ -42,38 +46,29 @@ class KnownSourceReference(Qualifier):
 class SourceReference:
     identifier = 'http://gedcomx.org/v1/SourceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
-
+    
     def __init__(self,
-                 description: URI, descriptionId: Optional[str] = None, attribution: Optional[Attribution] = None, qualifiers: Optional[List[Qualifier]] = []) -> None:
+                 description: URI | object | None = None,
+                 descriptionId: Optional[str] = None,
+                 attribution: Optional[Attribution] = None,
+                 qualifiers: Optional[List[Qualifier]] = None
+                 ) -> None:
         
-        #if not isinstance(description,URI): raise ValueError(f"description is of type {type(description)}")
-
-        from .SourceDescription import SourceDescription
-        self._description_object = None
-        if isinstance(description,URI):
-            #TODO See if Local, If not try to resolve,
-            self._description_object = description
-            
-        elif isinstance(description,SourceDescription):
-            self._description_object = description
-            if hasattr(description,'_uri'):
-                self.description = description._uri
-            else:
-                assert False
-                self.description = URI(object=description)
-                description._uri = self.description
-                description._object = description
-        else:
-            raise ValueError(f"'description' must be of type 'SourceDescription' or 'URI', type: {type(description)} was provided")
-        
-        #self.description = description
+        self.description = description
         self.descriptionId = descriptionId
         self.attribution = attribution
-        self.qualifiers = qualifiers
+        self.qualifiers = qualifiers if qualifiers and isinstance(qualifiers, list) else [] 
 
     def add_qualifier(self, qualifier: Qualifier):
-        if isinstance(qualifier, Qualifier):
+        if isinstance(qualifier, (Qualifier,KnownSourceReference)):
+            if self.qualifiers:
+                #TODO Prevent Duplicates
+                for current_qualifier in self.qualifiers:
+                    if qualifier == current_qualifier:
+                        return
             self.qualifiers.append(qualifier)
+            return
+        raise ValueError("The 'qualifier' must be type 'Qualifier' or 'KnownSourceReference', not " + str(type(qualifier))) 
     
     def append(self, text_to_add: str):
         if text_to_add and isinstance(text_to_add, str):
@@ -86,83 +81,33 @@ class SourceReference:
     
     @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
-
         # Only add Relationship-specific fields
-        sourcereference_fields = {
-            'description':self._description_object._uri if self._description_object else None,
+        type_as_dict = {
+            'description':self.description._as_dict_ if self.description else None,
             'descriptionId': self.descriptionId.replace("\n"," ").replace("\r"," ") if self.descriptionId else None,
-            'attribution': self.attribution if self.attribution else None,
+            'attribution': self.attribution._as_dict_ if self.attribution else None,
             'qualifiers':[qualifier.value for qualifier in self.qualifiers ] if self.qualifiers else None
             }
+        return Serialization.serialize_dict(type_as_dict)
 
-        # Serialize and exclude None values
-        for key, value in sourcereference_fields.items():
-            if value is not None:
-                sourcereference_fields[key] = _serialize(value)
-
-        return sourcereference_fields
+        
+        
 
     @classmethod
-    def _from_json_(cls, data: dict):
-        print(data)
-        
+    def _from_json_(cls, data: dict):         
         """
-        Rehydrate a SourceReference from the dict form produced by _as_dict_.
+        Rehydrate a SourceReference from the dict passed down from JSON deserialization.
+        NOTE: This does not resolve references to SourceDescription objects.
         """
-        from .SourceDescription import SourceDescription
-
-        # 1) Reconstruct the SourceDescription object
-        desc_json = data.get('description')
-        #if not desc_json:
-        #    raise ValueError("SourceReference JSON missing 'description'")
-        #desc_obj = SourceDescription._from_json_(desc_json)
-        desc_obj = URI.from_url(data.get('description')) #TODO <--- URI Reference
-        
-
-        # 2) Simple fields
-        description_id = data.get('descriptionId')
-        
-        # 3) Attribution (if present)
-        attrib = None
-        if data.get('attribution') is not None:
-            attrib = Attribution._from_json_(data['attribution'])
+        from .Serialization import Serialization
+        return Serialization.deserialize(data, SourceReference)
+    
         
-        # 4) Qualifiers list
-        raw_quals = data.get('qualifiers', [])
-        qualifiers: List[Qualifier] = []
-        for q in raw_quals:
-            try:
-                # Try the known‐source enum first
-                qualifiers.append(KnownSourceReference(q))
-            except ValueError:
-                # Fallback to generic Qualifier
-                qualifiers.append(Qualifier(q))
-
-        # 5) Instantiate via your existing __init__
-        inst = cls(
-            description=desc_obj,
-            descriptionId=description_id,
-            attribution=attrib,
-            qualifiers=qualifiers
-        )
-        return inst
 
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False  
 
         return (
-            self.description._uri == other.description._uri
+            self.description.uri == other.description.uri
         )

gedcomx/Subject.py

@@ -4,11 +4,12 @@ from typing import List, Optional
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
 from .EvidenceReference import EvidenceReference
-from .Identifier import Identifier
+from .Identifier import Identifier, IdentifierList
 from .Note import Note
-from .Serialization import serialize_to_dict
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
+from .Extensions.rs10.rsLink import _rsLinkList
 
 class Subject(Conclusion):
     identifier = 'http://gedcomx.org/v1/Subject'
@@ -18,22 +19,23 @@ class Subject(Conclusion):
                  id: Optional[str],
                  lang: Optional[str] = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  extracted: Optional[bool] = None,
                  evidence: Optional[List[EvidenceReference]] = [],
                  media: Optional[List[SourceReference]] = [],
-                 identifiers: Optional[List[Identifier]] = [],
-                 uri: Optional[URI] = None) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+                 identifiers: Optional[IdentifierList] = None,
+                 uri: Optional[Resource] = None,
+                 links: Optional[_rsLinkList] = None) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution,links=links)
         self.extracted = extracted
         self.evidence = evidence
         self.media = media
-        self.identifiers = identifiers
+        self.identifiers = identifiers if identifiers else IdentifierList()
+        self.uri = uri
         
-    
     def add_identifier(self, identifier_to_add: Identifier):
         if identifier_to_add and isinstance(identifier_to_add,Identifier):
             for current_identifier in self.identifiers:
@@ -61,7 +63,7 @@ class Subject(Conclusion):
             "extracted": self.extracted,
             "evidence": [evidence_ref for evidence_ref in self.evidence] if self.evidence else None,
             "media": [media for media in self.media] if self.media else None,
-            "identifiers": [identifier for identifier in self.identifiers] if self.identifiers else None
+            "identifiers": self.identifiers._as_dict_ if self.identifiers else None
                            
         })
 

gedcomx/TextValue.py

@@ -13,7 +13,8 @@ class TextValue:
             raise ValueError(f"Cannot append object of type {type(value_to_append)}.")
         self.value += ' ' + value_to_append
     
-    def _prop_dict(self):
+    @property
+    def _as_dict_(self):
         return {
             "lang":self.lang if self.lang else None,
             "value":self.value if self.value else None