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

{gedcom_x-0.5.1.dist-info → gedcom_x-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcom-x
-Version: 0.5.1
+Version: 0.5.2
 Summary: Python implimentation of gedcom-x standard
 Author-email: "David J. Cartwright" <davidcartwright@hotmail.com>
 License: MIT

gedcom_x-0.5.2.dist-info/RECORD

@@ -0,0 +1,42 @@
+gedcomx/Address.py,sha256=b_4X1w_FX6vPwpo4dVez7QlI5jn8w3dC0bWUlv_0IjM,4810
+gedcomx/Agent.py,sha256=4o1Gi_l_QsEgLLZzvFZ4SNUvla0O01jzUBXPniNcQ1g,8304
+gedcomx/Attribution.py,sha256=FVEjOiJorne1gxbL6CBwThC4CUfynVklpOsfVSO-pCg,3800
+gedcomx/Conclusion.py,sha256=lpMGr_S-KdVAB5L0h9L1d0qZOMJZGeCy90YplB1F3i8,6490
+gedcomx/Coverage.py,sha256=FuVsLDAhzS4HjNHKOHCjwQcvnxd4Uf_EeF3QcDEbems,912
+gedcomx/Date.py,sha256=N6-gDOLLCT_3_5bhS_4REP25LzEnOJpE6hNlMaYqxMA,2216
+gedcomx/Document.py,sha256=uSTEgtu1s8V_2IJaCxVS6A20Ho06FOUUZ7GWLeOmV8w,2231
+gedcomx/Event.py,sha256=x2jpWu27WCaksvNAGzsJ499rsugcbJ1DVELc-rBnFXo,9563
+gedcomx/EvidenceReference.py,sha256=WXZpmcKzwb3lYQmGVf-TY2IsbNG3fIInPY1khRjtOSg,348
+gedcomx/Exceptions.py,sha256=fzYtJ8d9C3oN-NMl0VMBc3U6ED41yu23dN885-_9brI,383
+gedcomx/Fact.py,sha256=emh3WsN-4mzSFXHt-3DffRLK9JPctG-PzRcrJkIcuao,24396
+gedcomx/Gedcom.py,sha256=v7XM0x8VX77uPPe5T3vB8AIxDhV65evXXW_kvH_HtXo,14954
+gedcomx/GedcomX.py,sha256=jaLLYA4J6k9jFOKfLeus0g0RWyKtmqycKkDrrp6iZLs,62456
+gedcomx/Gender.py,sha256=SH7ZyjSQ2Vi9PEQKN0uTZrKOma79QO7a_dJ-2lpMp0c,3925
+gedcomx/Group.py,sha256=VNI_cI_-YnJ9cHzwMmHD8qwDNMe89kEocPuQ67rwStA,1606
+gedcomx/Identifier.py,sha256=PIk2NedDm9a3XHJiX_hHv17xYqVpR2OVEIrxPM7jV88,6617
+gedcomx/Logging.py,sha256=vBDOjawVXc4tCge1laYjy6_2Ves-fnGzG0m6NnLZejE,624
+gedcomx/Name.py,sha256=xQWdvtSjd6jr-OnG73oMqqz0zaCcy-R3ChJ5KYnNECc,12733
+gedcomx/Note.py,sha256=cvV4-fCZ0oh2zXfzD-YYoIM_WTox-fk2_bfl3i4CoNc,2251
+gedcomx/OnlineAccount.py,sha256=P24o98IXo_8XQoICYZPgALjdzS0q8t2l4DU3Od9KxyI,291
+gedcomx/Person.py,sha256=IwCyxcbqdKxo0uN8O6R3FznES27ZSvM_kAIPcZwLoTg,9298
+gedcomx/PlaceDescription.py,sha256=doU2sAMZQIpfTi-sKAeo_mCitUfOOgy_G5OrRJ8YjBk,2934
+gedcomx/PlaceReference.py,sha256=ti7cFxKTd-1sTB5tGmPyTnYIxLZ7CF7_YCHbF9m-4K0,1137
+gedcomx/Qualifier.py,sha256=mZ_GWT3gca8g9nWidlXIRTN5dEtf_rmnLHYl1jJkQYs,728
+gedcomx/Relationship.py,sha256=2Ng6eNYHisusWUE-ufHfgGjU99dDBMx6ySRRsp3prnk,4959
+gedcomx/Resource.py,sha256=iBymUXv1-2u6qVVKsS16NaU6I_pYFZpN9mDz2vVUzLY,1650
+gedcomx/Serialization.py,sha256=wy-XRSM7Q9MyQ_dVP8gv8mwZ8a-bS7znSS-2DV6XOLU,2819
+gedcomx/SourceCitation.py,sha256=aW-lEb7bT9QU49GiBjJppFMBvtisR6fhVVuXjr5y4vQ,742
+gedcomx/SourceDescription.py,sha256=LBYp2s5WfH0jENYIog53OnnuzTPXwqjOy4CxsMT6Ud0,11883
+gedcomx/SourceReference.py,sha256=rHq0aD8wkNFj1hlm2cwd-RQe1C5GosDLDwg6-8fl9VU,7571
+gedcomx/Subject.py,sha256=1EqvKvudtZ8ky9QYFqQqAeaPzSsdWpAeeorvW05vxCM,3223
+gedcomx/TextValue.py,sha256=6B0wMxL0nigFNzhXZDhbTONvFGbnM2t2NcDZiZuu4Zw,1112
+gedcomx/TopLevelTypeCollection.py,sha256=nvTO6GwFwEZk9jX4fVqhy75ygsshomNb20tnlExKqyY,1495
+gedcomx/URI.py,sha256=SSxp8QWdxgEmD4sOgfjBFWG3kqoDtWg0IHSTQXbfhU8,4230
+gedcomx/Zip.py,sha256=lBxcv-Vip45884EHj56wZJJ5I36Q38UuHUidDxQBoS8,14
+gedcomx/_Links.py,sha256=--7d7PA80EeKCLtDOGOMp8QjLB679qnmVmHHakucEoo,972
+gedcomx/__init__.py,sha256=Bv5g_0UT2dHfzpD4k-AuVDfUgbJHqj5ee16ExFvQxXs,1439
+gedcomx/g7interop.py,sha256=KO4EQrvoGBSEPzLkWtO7E8-oZHmzL-q-_QRLQjhUNo4,9944
+gedcom_x-0.5.2.dist-info/METADATA,sha256=4GZGTw_sws2qevHyOPaFE6WuPmz8C-PWWNIXg42DCLY,633
+gedcom_x-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gedcom_x-0.5.2.dist-info/top_level.txt,sha256=smVBF4nxSU-mzCd6idtRYTbYjPICMMi8pTqewEmqF8Y,8
+gedcom_x-0.5.2.dist-info/RECORD,,

gedcomx/Address.py

@@ -1,7 +1,28 @@
 from typing import Optional
 import json
 
+from .Serialization import Serialization
+
 class Address:
+    """A GedcomX Address Data Type
+    A GedcomX Address Data Type.
+
+    Represents a postal address according to the GedcomX conceptual model.
+
+    Args:
+        value (str, optional): A complete address as a single string.
+        city (str, optional): Name of the city or town.
+        country (str, optional): Name of the country.
+        postalCode (str, optional): Postal or ZIP code.
+        stateOrProvince (str, optional): Name of the state, province, or region.
+        street (str, optional): First street address line.
+        street2 (str, optional): Second street address line.
+        street3 (str, optional): Third street address line.
+        street4 (str, optional): Fourth street address line.
+        street5 (str, optional): Fifth street address line.
+        street6 (str, optional): Sixth street address line.
+    """
+
     identifier = "http://gedcomx.org/v1/Address"
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -30,17 +51,24 @@ class Address:
         self.street6 = street6
 
     @property
-    def value(self) -> Optional[str]:
-        if self._value:
-            return self._value
+    def value(self) -> str: 
         return ', '.join(filter(None, [
-            self._street, self._street2, self._street3,
-            self._street4, self._street5, self._street6,
-            self._city, self._stateOrProvince,
-            self._postalCode, self._country
+            self.street, self.street2, self.street3,
+            self.street4, self.street5, self.street6,
+            self.city, self.stateOrProvince,
+            self.postalCode, self.country
         ]))
     
-         
+    @value.setter
+    def value(self,value: str):
+        raise NotImplementedError("Parsing of a full address is not implimented.")
+    
+    def _append(self,value):
+        if self._value:
+            self._value = self._value + ' ' + value
+        else:
+            self._value = value
+             
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
@@ -82,9 +110,8 @@ class Address:
         return ', '.join(filtered_parts)
     
     @property
-    def __as_dict__(self):
-        return {
-            #"value": self._value if self._value else None,
+    def _as_dict_(self):
+        type_as_dict =  {
             "city": self.city if self.city else None,
             "country": self.country if self.country else None,
             "postalCode": self.postalCode if self.postalCode else None,
@@ -97,4 +124,6 @@ class Address:
             "street6": self.street6 if self.street6 else None
         }
 
+        return Serialization.serialize_dict(type_as_dict)
+
 

gedcomx/Agent.py

@@ -4,12 +4,49 @@ import uuid
 from typing import List, Optional
 
 from .Address import Address
-from .Identifier import Identifier
+#from .Attribution import Attribution
+from .Identifier import Identifier, IdentifierList
+
 from .OnlineAccount import OnlineAccount
 from .TextValue import TextValue
+from .Resource import Resource
 from .URI import URI
+from .Serialization import Serialization
+
 
 class Agent:
+    """A GedcomX Agent Data Type.
+
+    Represents an agent entity such as a person, organization, or software 
+    responsible for creating or modifying genealogical data, as defined in 
+    the GedcomX conceptual model.
+
+    Static Methods:
+        default_id_generator(): Generates a short, URL-safe Base64-encoded UUID 
+            for use as a default agent identifier.
+
+    Args:
+        id (str, optional): A unique identifier for this agent. If not provided, 
+            one may be generated automatically using `default_id_generator()`.
+        identifiers (IdentifierList, optional): A list of alternate identifiers for this agent.
+        names (List[TextValue], optional): Names associated with the agent. Defaults to an empty list.
+        homepage (URI, optional): A link to the agent's homepage or primary website.
+        openid (URI, optional): The OpenID identifier for the agent.
+        accounts (List[OnlineAccount], optional): Online accounts associated with the agent.
+            Defaults to an empty list.
+        emails (List[URI], optional): Email addresses associated with the agent.
+            Defaults to an empty list.
+        phones (List[Resource], optional): Phone numbers associated with the agent.
+            Defaults to an empty list.
+        addresses (List[Address], optional): Postal addresses associated with the agent.
+            Defaults to an empty list.
+        person (Person, optional): A reference to the person represented 
+            by the agent. Accepts a `Person` object or a `Resource` reference. 
+            Declared as `object` to avoid circular imports.
+        attribution (Attribution, optional): Attribution information related to the agent.
+        uri (Resource, optional): A URI reference for this agent.
+    """
+    
     @staticmethod
     def default_id_generator():
         # Generate a standard UUID
@@ -21,7 +58,7 @@ class Agent:
         return short_uuid
     
     def __init__(self, id: Optional[str] = None,
-                    identifiers: Optional[List[Identifier]] = [], 
+                    identifiers: Optional[IdentifierList] = None, 
                     names: Optional[List[TextValue]] = [], 
                     homepage: Optional[URI] = None, 
                     openid: Optional[URI] = None, 
@@ -29,25 +66,33 @@ class Agent:
                     emails: Optional[List[URI]] = [], 
                     phones: Optional[List[URI]] = [], 
                     addresses: Optional[List[Address]] = [], 
-                    person: Optional[object] | Optional[URI] = None, # should be of Type 'Person', 'object' to avoid circular imports
-                    uri: URI = None): 
+                    person: Optional[object] | Optional[Resource] = None, # should be of Type 'Person', 'object' to avoid circular imports
+                    #xnotes: Optional[List[Note]] = None,
+                    attribution: Optional[object] = None, # Added for compatibility with GEDCOM5/7 Imports
+                    uri: Optional[URI | Resource] = None): 
         
         self._id_generator = Agent.default_id_generator
 
-        self.id = id if id else self._id_generator()
-        self.identifiers = identifiers
-        self.names = names
-        self.homepage = homepage
-        self.openid = openid
-        self.accounts = accounts
-        self.emails = emails
-        self.phones = phones
-        self.addresses = addresses
-        
-        self._uri = URI(fragment="agent:"+ self.id)
-    
+        self.id = id if id else None #TODO self._id_generator()
+        self.identifiers = identifiers or IdentifierList()
+        self.names = names if names else []
+        self.homepage = homepage or None
+        self.openid = openid or None
+        self.accounts = accounts or []
+        self.emails = emails or []
+        self.phones = phones or []
+        self.addresses = addresses if addresses else []
+        self.xnotes = []
+        self.attribution = attribution or None
+        self.uri = URI(fragment=self.id)
+  
     def _append_to_name(self, text_to_append: str):
-        self.names[0].value = self.names[0].value + text_to_append
+        if self.names and self.names[0] and self.names[0].value:
+            self.names[0].value = self.names[0].value + text_to_append
+        elif self.names and self.names[0]:
+            self.names[0].value = text_to_append
+        else:
+            raise ValueError() #TODO
 
     def add_address(self, address_to_add: Address):
         if address_to_add and isinstance(address_to_add, Address):
@@ -68,16 +113,77 @@ class Agent:
         else:
             raise ValueError(f'name must be of type str or TextValue, recived {type(name_to_add)}')
     
+    def add_note(self, note_to_add: 'Note'):
+        from .Note import Note
+        if note_to_add and isinstance(note_to_add,Note):
+            self.xnotes.append(note_to_add)
+        else:
+            raise ValueError(f'note must be of type Note, recived {type(note_to_add)}')
+    
+    def add_identifier(self, identifier_to_add: Identifier):
+        self.identifiers.append(identifier_to_add)
+    
     @property
-    def __as_dict__(self):
-        return {
+    def _as_dict_(self):
+        type_as_dict = {
             "id": self.id if self.id else None,
-            "identifiers": [identifier.__as_dict__() for identifier in self.identifiers],
-            "names": [name._prop_dict() for name in self.names],
+            "identifiers": self.identifiers._as_dict_ if self.identifiers else None,
+            "names": [name._as_dict_ for name in self.names],
             "homepage": self.homepage if self.homepage else None,
             "openid": self.openid if self.openid else None,
             "accounts": self.accounts if self.accounts else None,
             "emails": self.emails if self.emails else None,
             "phones": self.phones if self.phones else None,
-            "addresses": [address.__as_dict__ for address in self.addresses]
-        }
+            "addresses": [address._as_dict_ for address in self.addresses],
+            "notes": [note._as_dict_ for note in self.xnotes]
+        }
+        return Serialization.serialize_dict(type_as_dict)
+    
+    def __str__(self):
+        """
+        Return a human-readable string representation of the Agent.
+
+        Returns:
+            str: A concise description including ID, primary name (if any), and type of agent.
+        """
+        primary_name = self.names[0].value if self.names else "Unnamed Agent"
+        homepage_str = f", homepage={self.homepage}" if self.homepage else ""
+        return f"Agent(id={self.id}, name='{primary_name}'{homepage_str})"
+
+    def __eq__(self, other):
+        """
+        Determine equality between two Agent instances.
+
+        Args:
+            other (Agent): The other object to compare against.
+
+        Returns:
+            bool: True if both objects represent the same agent, False otherwise.
+        """
+        '''
+        if not isinstance(other, Agent):
+            return NotImplemented
+        
+        return (
+            self.id == other.id and
+            self.identifiers == other.identifiers and
+            self.names == other.names and
+            self.homepage == other.homepage and
+            self.openid == other.openid and
+            self.accounts == other.accounts and
+            self.emails == other.emails and
+            self.phones == other.phones and
+            self.addresses == other.addresses and
+            self.person == other.person and
+            self.attribution == other.attribution and
+            self.uri == other.uri
+        )
+        '''
+        print(other)
+        print(self)
+        self_names = {n.value for n in self.names if hasattr(n, "value")}
+        other_names = {n.value for n in other.names if hasattr(n, "value")}
+        if self_names & other_names:  # intersection not empty
+            return True
+
+        return False

gedcomx/Attribution.py

@@ -1,67 +1,52 @@
+
 from datetime import datetime
 from typing import Optional, Dict, Any
 
-from .URI import URI
+from .Agent import Agent
+from .Resource import Resource, get_resource_as_dict
+from .Serialization import Serialization
 
 class Attribution:
-    identifier = 'http://gedcomx.org/v1/Attribution'
-    version = 'http://gedcomx.org/conceptual-model/v1'
+    """Attribution Information for a Genealogy, Conclusion, Subject and child classes
+
+    Args:
+        contributor (Agent):            Contributor to object being attributed.
+        modified (timestamp):           timestamp for when this record was modified.
+        changeMessage (str):            Birth date (YYYY-MM-DD).
+        creator (Agent, optional):      Creator of object being attributed.
+        created (timestamp):            timestamp for when this record was created
 
-    def __init__(self,contributor: Optional[URI],
-                 modified: Optional[datetime],
-                 changeMessage: Optional[str],
-                 creator: Optional[URI],
-                 created: Optional[datetime]) -> None:
+    Raises:
         
+    """
+    identifier = 'http://gedcomx.org/v1/Attribution'
+    version = 'http://gedcomx.org/conceptual-model/v1'
 
-        from .Agent import Agent
-        self._contributor_object = None
+    def __init__(self,contributor: Optional[Agent | Resource] = None,
+                 modified: Optional[datetime] = None,
+                 changeMessage: Optional[str] = None,
+                 creator: Optional[Agent | Resource] = None,
+                 created: Optional[datetime] = None) -> None:
+               
+        self.contributor = contributor
         self.modified = modified
         self.changeMessage = changeMessage
         self.creator = creator
         self.created = created
-
-
-        if isinstance(contributor,URI):
-            # TODO DEAL WITH URI <------------------------------------------------------------------------------------------------------------------
-            self._contributor_object = contributor
-        elif isinstance(contributor,Agent):
-            self._contributor_object = contributor
-            if hasattr(contributor,'_uri'):
-                self.contributor = contributor._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(contributor)} was provided, with value: {contributor}")
-    
+        
     @property
     def _as_dict_(self) -> Dict[str, Any]:
         """
         Serialize Attribution to a JSON-ready dict, skipping None values.
         """
-        def _fmt_dt(dt: datetime) -> str:
-            # ISO 8601 format
-            return dt.isoformat()
-
-        data: Dict[str, Any] = {}
-        if self._contributor_object:
-            data['contributor'] = (self._contributor_object._as_dict_
-                                   if hasattr(self._contributor_object, '_as_dict_') else
-                                   None)
-        if self.created:
-            data['created'] = _fmt_dt(self.created)
-        if self.creator:
-            data['creator'] = (self.creator._prop_dict()
-                                if hasattr(self.creator, '_prop_dict') else
-                                self.creator._prop_dict())
-        if self.modified:
-            data['modified'] = _fmt_dt(self.modified)
-        if self.changeMessage is not None:
-            data['changeMessage'] = self.changeMessage    
-        return data
+        type_as_dict: Dict[str, Any] = {}
+        type_as_dict['contributor'] = get_resource_as_dict(self.contributor)       
+        type_as_dict['modified'] = self.modified if self.modified else None
+        type_as_dict['changeMessage'] = self.changeMessage if self.changeMessage else None 
+        type_as_dict['creator'] = get_resource_as_dict(self.creator)         
+        type_as_dict['created'] = self.created if self.created else None
+                    
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'Attribution':
@@ -70,22 +55,21 @@ class Attribution:
         Handles 'created' and 'modified' as ISO strings or epoch ms ints.
         """
         # contributor
+        
         contrib = None
         if 'contributor' in data:
-            raw = data['contributor']
-            if isinstance(raw, dict):
-                contrib = URI._from_json_(raw)
-            elif isinstance(raw, str):
-                contrib = URI(uri=raw)
+            contrib_data = data['contributor']
+            
+            contrib = Resource(contrib_data['resource'],contrib_data['resourceId'])
 
         # creator
         creat = None
         if 'creator' in data:
             raw = data['creator']
             if isinstance(raw, dict):
-                creat = URI._from_json_(raw)
+                creat = Resource._from_json_(raw)
             elif isinstance(raw, str):
-                creat = URI(uri=raw)
+                creat = Resource(uri=raw)
 
         # parse created date
         raw_created = data.get('created')

gedcomx/Conclusion.py

@@ -5,10 +5,15 @@ import warnings
 from typing import List, Optional
 
 from .Attribution import Attribution
+#from .Document import Document
 from .Note import Note
 from .Qualifier import Qualifier
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource, URI
+from ._Links import _LinkList, _Link
+
+from collections.abc import Sized
 
 class ConfidenceLevel(Qualifier):
     High = "http://gedcomx.org/High"
@@ -25,6 +30,37 @@ class ConfidenceLevel(Qualifier):
         return descriptions.get(self, "No description available.")
     
 class Conclusion:
+    """
+    Represents a conclusion in the GEDCOM X conceptual model. A conclusion is a 
+    genealogical assertion about a person, relationship, or event, derived from 
+    one or more sources, with optional supporting metadata such as confidence, 
+    attribution, and notes.
+
+    Args:
+        id (str, optional): A unique identifier for the conclusion. If not provided, 
+            a UUID-based identifier will be automatically generated.
+        lang (str, optional): The language code of the conclusion. Defaults to 'en'.
+        sources (list[SourceReference], optional): A list of source references that 
+            support the conclusion.
+        analysis (Document | Resource, optional): A reference to an analysis document 
+            or resource that supports the conclusion.
+        notes (list[Note], optional): A list of notes providing additional context. 
+            Defaults to an empty list.
+        confidence (ConfidenceLevel, optional): The contributor's confidence in the 
+            conclusion (High, Medium, or Low).
+        attribution (Attribution, optional): Information about who contributed the 
+            conclusion and when.
+        uri (Resource, optional): A URI reference for the conclusion. Defaults to a 
+            URI with the fragment set to the `id`.
+        links (_LinkList, optional): A list of links associated with the conclusion. 
+            Defaults to an empty `_LinkList`.
+
+    Methods:
+        add_note(note_to_add): Adds a note if it is not a duplicate and does not 
+            exceed the maximum allowed notes.
+        add_source(source_to_add): Adds a source reference if it is not already present.
+        add_link(link): Adds a link to the `_LinkList`.
+    """
     identifier = 'http://gedcomx.org/v1/Conclusion'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -41,28 +77,30 @@ class Conclusion:
     def __init__(self,
                  id: Optional[str],
                  lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[object | Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
-                 uri: Optional[URI] = None,
-                 max_note_count: int = 20) -> None:
+                 uri: Optional[Resource] = None,
+                 _max_note_count: int = 20,
+                 links: Optional[_LinkList] = None) -> None:
         
         self._id_generator = Conclusion.default_id_generator
 
         self.id = id if id else self._id_generator()
         self.lang = lang
-        self.sources = sources
+        self.sources = sources if sources else []
         self.analysis = analysis
-        self.notes = notes
+        self.notes = notes if notes else []
         self.confidence = confidence
         self.attribution = attribution
-        self.max_note_count = max_note_count
-        self._uri = uri if uri else URI(fragment=id)
+        self.max_note_count = _max_note_count
+        self.uri = uri if uri else URI(fragment=id)
+        self.links = links if links else _LinkList()    #NOTE This is not in specification, following FS format
     
     def add_note(self,note_to_add: Note):
-        if len(self.notes) >= self.max_note_count:
+        if self.notes and len(self.notes) >= self.max_note_count:
             warnings.warn(f"Max not count of {self.max_note_count} reached for id: {self.id}")
             return False
         if note_to_add and isinstance(note_to_add,Note):
@@ -79,48 +117,25 @@ class Conclusion:
             self.sources.append(source_to_add)
         else:
             raise ValueError()
-    
-    '''
-    def _as_dict_(self):
-        return {
-            'id':self.id,
-            'lang':self.lang,
-            'sources': [source._prop_dict() for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
-            'notes':"Add notes here",
-            'confidence':self.confidence
-        }
-    '''
+        
+    def add_link(self,link: _Link):
+        if link and isinstance(link,_Link):
+            self.links.add(link)
     
     @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
-        conclusion_fields = {
+        type_as_dict = {
             'id':self.id,
             'lang':self.lang,
-            'sources': [source for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
+            'sources': [source._as_dict_ for source in self.sources] if self.sources else None,
+            'analysis': self.analysis if self.analysis else None,
             'notes': [note for note in self.notes] if self.notes else None,
-            'confidence':self.confidence
+            'confidence':self.confidence,
+            'attribution':self.attribution,
+            'links':self.links._as_dict_ if self.links else None
         }
-
-        # Serialize and exclude None values
-        for key, value in conclusion_fields.items():
-            if value is not None:
-                                conclusion_fields[key] = _serialize(value)
-        return conclusion_fields
+      
+        return Serialization.serialize_dict(type_as_dict) 
     
     def __eq__(self, other):
         if not isinstance(other, self.__class__):