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

gedcomx/Resource.py

@@ -1,5 +1,6 @@
 from typing import List, Optional
 
+
 from .URI import URI
     
 class Resource:
@@ -16,7 +17,7 @@ class Resource:
     """
     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)
+        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
@@ -31,9 +32,23 @@ class Resource:
    
     @property
     def _as_dict_(self):
-        return {'resource':self.resource.value,
+        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:
@@ -58,4 +73,3 @@ def get_resource_as_dict(value):
         print((f"value: {value} as inproper attributes"))
         exit()
 
-    

gedcomx/Serialization.py

@@ -1,42 +1,25 @@
 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)
-        else:
-            empty_fields.append(key)
-    
-    for key in empty_fields:
-            del values_dict[key]
-                
-    return values_dict
 
 class Serialization:
 
@@ -78,3 +61,341 @@ class Serialization:
                     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:
+            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/SourceDescription.py

@@ -78,7 +78,7 @@ class SourceDescription:
                  notes: Optional[List[Note]] = None,
                  attribution: Optional[Attribution] = None,
                  rights: Optional[List[Resource]] = [],
-                 coverage: Optional[Coverage] = None, # Coverage
+                 coverage: Optional[List[Coverage]] = None, # Coverage
                  descriptions: Optional[List[TextValue]] = None,
                  identifiers: Optional[IdentifierList] = None,
                  created: Optional[Date] = None,
@@ -180,18 +180,15 @@ class SourceDescription:
     
     @property
     def _as_dict_(self) -> Dict[str, Any]:
-        
-
-        
         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,
-            'mediator': get_resource_as_dict(self.mediator),
-            'publisher': get_resource_as_dict(self.publisher),
-            'authors': [get_resource_as_dict(a) 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._as_dict_ if self.analysis else None,
             'componentOf': self.componentOf._as_dict_ if self.componentOf else None,
@@ -199,13 +196,13 @@ class SourceDescription:
             'notes': [n._as_dict_ for n in self.notes] or None,
             'attribution': self.attribution._as_dict_ if self.attribution else None,
             'rights': [r._as_dict_ for r in self.rights] or None,
-            'coverage': self.coverage._as_dict_ if self.coverage else 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': get_resource_as_dict(self.repository),
+            'repository': self.repository._as_dict_ if self.repository else None,
             'uri': self.uri.value
         }
         

gedcomx/SourceReference.py

@@ -4,6 +4,7 @@ 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
@@ -53,34 +54,21 @@ class SourceReference:
                  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 = Resource(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.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):
@@ -93,82 +81,28 @@ 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.uri if self.description 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._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 {
-            k: v
-            for k, v in sourcereference_fields.items()
-            if v is not None and not (isinstance(v, Sized) and len(v) == 0)
-        }
+        
         
 
     @classmethod
-    def _from_json_(cls, data: dict):
-                
+    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__):

gedcomx/Subject.py

@@ -9,7 +9,7 @@ from .Note import Note
 from .Serialization import Serialization
 from .SourceReference import SourceReference
 from .Resource import Resource
-from ._Links import _LinkList
+from .Extensions.rs10.rsLink import _rsLinkList
 
 class Subject(Conclusion):
     identifier = 'http://gedcomx.org/v1/Subject'
@@ -28,14 +28,14 @@ class Subject(Conclusion):
                  media: Optional[List[SourceReference]] = [],
                  identifiers: Optional[IdentifierList] = None,
                  uri: Optional[Resource] = None,
-                 links: Optional[_LinkList] = None) -> 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: