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

gedcomx/Gender.py

@@ -5,11 +5,13 @@ from gedcomx.Attribution import Attribution
 from gedcomx.Conclusion import ConfidenceLevel
 from gedcomx.Note import Note
 from gedcomx.SourceReference import SourceReference
-from gedcomx.URI import URI
+from gedcomx.Resource import Resource
 
 from .Conclusion import Conclusion
 from .Qualifier import Qualifier
 
+from collections.abc import Sized
+
 class GenderType(Enum):
     Male = "http://gedcomx.org/Male"
     Female = "http://gedcomx.org/Female"
@@ -33,16 +35,67 @@ class Gender(Conclusion):
     def __init__(self,
                  id: Optional[str] = None,
                  lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
-                 notes: Optional[List[Note]] = [],
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[Resource] = None,
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None, 
-                 type: GenderType = None
+                 type: Optional[GenderType] = None
                  ) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        super().__init__(id=id, lang=lang, sources=sources, analysis=analysis, notes=notes, confidence=confidence, attribution=attribution)
         self.type = type
     
+    @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
+            
+        gender_fields = super()._as_dict_  # Start with base class fields
+        # Only add Relationship-specific fields
+        gender_fields.update({
+            'type':self.type.value if self.type else None
+                           
+        })
+        
+        # Serialize and exclude None values
+        for key, value in gender_fields.items():
+            if value is not None:
+                gender_fields[key] = _serialize(value)
+
+        return {
+            k: v
+            for k, v in gender_fields.items()
+            if v is not None and not (isinstance(v, Sized) and len(v) == 0)
+        }
+        
+        return gender_fields
+
     @classmethod
-    def _from_json_(cls,json_text):
-        return Gender()
+    def _from_json_(cls,data):
+        id = data.get('id') if data.get('id') else None
+        lang = data.get('lang',None)
+        sources = [SourceReference._from_json_(o)   for o in data.get('sources')] if data.get('sources') else None
+        analysis = None #URI.from_url(data.get('analysis')) if data.get('analysis',None) else None,
+        notes = [Note._from_json_(o) for o in data.get('notes',[])]
+        #TODO confidence = ConfidenceLevel(data.get('confidence')),
+        attribution = Attribution._from_json_(data.get('attribution')) 
+        type = GenderType(data.get('type'))
+        
+        
+        return Gender(id=id,
+                      lang=lang,
+                      sources=sources,
+                      analysis=analysis,
+                      notes=notes,
+                      attribution=attribution,
+                      type=type)
+        

gedcomx/Group.py

@@ -9,7 +9,7 @@ from .Identifier import Identifier
 from .Note import Note
 from .PlaceReference import PlaceReference
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 from .TextValue import TextValue
 from .Subject import Subject
@@ -22,14 +22,14 @@ class GroupRole:
     identifier = 'http://gedcomx.org/v1/GroupRole'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, person: URI,type: Optional[Enum], date: Optional[Date],details: Optional[str]) -> None:
+    def __init__(self, person: Resource,type: Optional[Enum], date: Optional[Date],details: Optional[str]) -> None:
         pass
 
 class Group(Subject):
     identifier = 'http://gedcomx.org/v1/Group'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str | None, lang: str | None, sources: SourceReference | None, analysis: URI | None, notes: Note | None, confidence: ConfidenceLevel | None, attribution: Attribution | None, extracted: bool | None, evidence: List[EvidenceReference] | None, media: List[SourceReference] | None, identifiers: List[Identifier] | None,
+    def __init__(self, id: str | None, lang: str | None, sources: SourceReference | None, analysis: Resource | None, notes: Note | None, confidence: ConfidenceLevel | None, attribution: Attribution | None, extracted: bool | None, evidence: List[EvidenceReference] | None, media: List[SourceReference] | None, identifiers: List[Identifier] | None,
                  names: TextValue,
                  date: Optional[Date],
                  place: Optional[PlaceReference],

gedcomx/Identifier.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import List, Optional, Dict, Any
 
 from .Qualifier import Qualifier
+from .Resource import Resource
 from .URI import URI
 
 class IdentifierType(Enum):
@@ -11,6 +12,8 @@ class IdentifierType(Enum):
     Authority = "http://gedcomx.org/Authority"
     Deprecated = "http://gedcomx.org/Deprecated"
     Persistant = "http://gedcomx.org/Persistent"
+    External = "https://gedcom.io/terms/v7/EXID"
+    Other = "user provided"
     
     @property
     def description(self):
@@ -35,10 +38,11 @@ class Identifier:
     identifier = 'http://gedcomx.org/v1/Identifier'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, value: Optional[URI], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
-        self.value = value
+    def __init__(self, value: Optional[List[URI]], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
+        if not isinstance(value,list):
+            value = [value]
         self.type = type
-    
+        self.values = value if value else []
     
     @property
     def _as_dict_(self):
@@ -54,9 +58,8 @@ class Identifier:
             else:
                 return str(value)  # fallback for unknown objects
 
-        
         identifier_fields = {
-            'value': self.value if self.value else None,
+            'value': self.values if self.values else None,
             'type': self.type.value if self.type else None
                            
         }
@@ -69,21 +72,101 @@ class Identifier:
         return identifier_fields
 
     @classmethod
-    def _from_json_(cls, data: Dict[str, Any]) -> 'Identifier':
+    def _from_json_(cls, data: Dict[str, Any]) -> 'Identifier | None':
         """
         Construct an Identifier from a dict parsed from JSON.
         """
+        #for name, member in IdentifierType.__members__.items():
+        #    print(name)
+
         # Parse value (URI dict or string)
-        
+        print('--------------',data)
         for key in data.keys():
             type = key
             value = data[key]
-        uri_obj: Optional[URI] = None
+        uri_obj: Optional[Resource] = None
         # TODO DO THIS BETTER
 
         # Parse type
         raw_type = data.get('type')
-        id_type: Optional[IdentifierType] = IdentifierType(raw_type)
+        if raw_type is None:
+            return None
+        id_type: Optional[IdentifierType] = IdentifierType(raw_type) if raw_type else None
+        return cls(value=value, type=id_type)
+
+class IdentifierList():
+    def __init__(self) -> None:
+        self.identifiers = {}
+    
+    def make_hashable(self, obj):
+        """Convert any object into a hashable representation."""
+        if isinstance(obj, dict):
+            # Convert dict to sorted tuple of key/value pairs
+            return tuple(sorted((k, self.make_hashable(v)) for k, v in obj.items()))
+        elif isinstance(obj, (list, set, tuple)):
+            # Convert sequences/sets into tuples
+            return tuple(self.make_hashable(i) for i in obj)
+        elif hasattr(obj,'_as_dict_'):
+            as_dict = obj._as_dict_
+            t = tuple(sorted((k, self.make_hashable(v)) for k, v in as_dict.items()))
+            return t
+        else:
+            return obj  # Immutable stays as is
+
+    def unique_list(self, items):
+        """Return a list without duplicates, preserving order."""
+        seen = set()
+        result = []
+        for item in items:
+            h = self.make_hashable(item)
+            if h not in seen:
+                seen.add(h)
+                result.append(item)
+        return result
+    
+    def append(self, identifier: Identifier):
+        if isinstance(identifier, Identifier): 
+            self.add_identifer(identifier)
+        else:
+            raise ValueError()
+
+    def add_identifer(self, identifier: Identifier):
+        if identifier and isinstance(identifier,Identifier):
+            if identifier.type.value in self.identifiers.keys():
+                self.identifiers[identifier.type.value].extend(identifier.values)
+            else:
+                self.identifiers[identifier.type.value] = identifier.values
+            print(self.identifiers[identifier.type.value])
+            self.identifiers[identifier.type.value] = self.unique_list(self.identifiers[identifier.type.value])
         
+    # TODO Merge Identifiers
+    def contains(self,identifier: Identifier):
+        if identifier and isinstance(identifier,Identifier):
+            if identifier.type.value in self.identifiers.keys():
+                pass
+    
+    def __get_item__(self):
+        pass
+
+    @classmethod
+    def _from_json_(cls,data):
+        identifier_list = IdentifierList()
+        for name, member in IdentifierType.__members__.items():
+            values = data.get(member.value,None)
+            if values:
+                identifier_list.add_identifer(Identifier(values,IdentifierType(member.value)))
+        return identifier_list
+    
+    @property
+    def _as_dict_(self):
+        identifiers_dict = {}
+        for key in self.identifiers.keys():
+            # Should always be flat due to unique_list in add method.
+            identifiers_dict[key] = [u.value for u in self.identifiers[key]]
+
+        return identifiers_dict
+
+
+
+
 
-        return cls(value=value, type=id_type)

gedcomx/Logging.py

@@ -0,0 +1,19 @@
+import logging
+
+def get_logger(name='gedcomx.log'):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter('[%(asctime)s] %(levelname)s - %(name)s - %(message)s')
+
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        # Optional: file logging
+        file_handler = logging.FileHandler(f"{name}.log", encoding="utf-8")
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger

gedcomx/Name.py

@@ -5,8 +5,9 @@ from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
 from .Date import Date
 from .Note import Note
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
 
 
 class NameType(Enum):
@@ -99,10 +100,11 @@ class NamePart:
         self.value = value
         self.qualifiers = qualifiers
     
-    def _prop_dict(self):
-        return {'type': self.type.value if self.type else None,
-                'value': self.value if self.value else None,
-                'qualifiers': [qualifier.value for qualifier in self.qualifiers]}
+    def _as_dict_(self):
+        return Serialization.serialize_dict(
+            {'type': self.type.value if self.type else None,
+             'value': self.value if self.value else None,
+             'qualifiers': [qualifier.value for qualifier in self.qualifiers] if self.qualifiers else None})
 
     def __eq__(self, other):
         if not isinstance(other, NamePart):
@@ -120,10 +122,12 @@ class NameForm:
         self.fullText = fullText
         self.parts = parts
     
-    def _prop_dict(self):
-        return {'lang': self.lang,
-                'fullText': self.fullText,
-                'parts': [part._prop_dict() for part in self.parts]}
+    @property
+    def _as_dict_(self):
+        return Serialization.serialize_dict(
+            {'lang': self.lang,
+             'fullText': self.fullText,
+             'parts': [part._as_dict_() for part in self.parts] if self.parts else None})
     
     def _fulltext_parts(self):
         pass
@@ -137,37 +141,40 @@ class Name(Conclusion):
         """
         Takes a string and returns a GedcomX Name Object
         """
-        text = text.replace("/","")
-        parts = text.rsplit(' ', 1)
-    
-        # Assign val1 and val2 based on the split
-        given = parts[0] if len(parts) > 1 else ""
-        surname = parts[1] if len(parts) > 1 else parts[0]
+        if text:
+            text = text.replace("/","")
+            parts = text.rsplit(' ', 1)
         
-        # Remove any '/' characters from both val1 and val2
-        #given = given.replace('/', '')
-        #surname = surname.replace('/', '')
+            # Assign val1 and val2 based on the split
+            given = parts[0] if len(parts) > 1 else ""
+            surname = parts[1] if len(parts) > 1 else parts[0]
+            
+            # Remove any '/' characters from both val1 and val2
+            #given = given.replace('/', '')
+            #surname = surname.replace('/', '')
 
-        given_name_part = NamePart(type = NamePartType.Given, value=given)
-        surname_part = NamePart(type = NamePartType.Surname, value=surname)
+            given_name_part = NamePart(type = NamePartType.Given, value=given)
+            surname_part = NamePart(type = NamePartType.Surname, value=surname)
 
-        name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
-        name = Name(type=NameType.BirthName,nameForms=[name_form])
+            name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
+            name = Name(type=NameType.BirthName,nameForms=[name_form])
+        else:
+            name = Name()
         return name
 
     def __init__(self, id: str = None,
                  lang: str = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: URI = None,
-                 notes: Optional[List[Note]] = [],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Resource = None,
+                 notes: Optional[List[Note]] = None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
                  type: Optional[NameType] = None,
-                 nameForms: NameForm = [],
+                 nameForms: Optional[List[NameForm]]= None,
                  date: Optional[Date] = None) -> None:
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
         self.type = type
-        self.nameForms = nameForms
+        self.nameForms = nameForms if nameForms else []
         self.date = date
     
     def _add_name_part(self, namepart_to_add: NamePart):
@@ -179,11 +186,38 @@ class Name(Conclusion):
     
     @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
+            
         name_as_dict = super()._as_dict_
+
         name_as_dict.update( {
             'type':self.type.value if self.type else None,
-            'nameForms': [nameForm._prop_dict() for nameForm in self.nameForms],
-            'date': self.date._prop_date() if self.date else None})
+            'nameForms': [nameForm._as_dict_ for nameForm in self.nameForms],
+            'date': self.date._as_dict_ if self.date else None})
+        
+        #del name_as_dict['id']
+        # Serialize and exclude None values
+        for key, value in name_as_dict.items():
+            if value is not None:
+                name_as_dict[key] = _serialize(value)
+
+        # 3) merge and filter out None *at the top level*
+        return {
+            k: v
+            for k, v in name_as_dict.items()
+            if v is not None
+        }
+    
         return name_as_dict
 
 def ensure_list(val):
@@ -223,7 +257,7 @@ Name._from_json_ = classmethod(lambda cls, data: cls(
     id=data.get('id'),
     lang=data.get('lang', 'en'),
     sources=[SourceReference._from_json_(s) for s in ensure_list(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,
     notes=[Note._from_json_(n) for n in ensure_list(data.get('notes'))],
     confidence=ConfidenceLevel._from_json_(data['confidence']) if data.get('confidence') else None,
     attribution=Attribution._from_json_(data['attribution']) if data.get('attribution') else None,
@@ -232,10 +266,5 @@ Name._from_json_ = classmethod(lambda cls, data: cls(
     date=Date._from_json_(data['date']) if data.get('date') else None
 ))
 
-Name._to_dict_ = lambda self: {
-    **self._as_dict_,
-    'type': self.type.value if self.type else None,
-    'nameForms': [nf._to_dict_() for nf in self.nameForms] if self.nameForms else [],
-    'date': self.date._prop_date() if self.date else None
-}
+
 

gedcomx/Note.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from .Attribution import Attribution
+from .Serialization import Serialization
 
 class Note:
     identifier = 'http://gedcomx.org/v1/Note'
@@ -10,24 +11,24 @@ class Note:
         self.lang = lang
         self.subject = subject
         self.text = text
-        self.attribution = attribution
-    
-    
+        self.attribution = attribution  
 
     def append(self, text_to_add: str):
         if text_to_add and isinstance(text_to_add, str):
             self.text = self.text + text_to_add
         else:
+            return #TODO
             raise ValueError("The text to add must be a non-empty string.")
     
     @property
     def _as_dict_(self):
-        return {
+        note_dict = {
             "lang":self.lang if self.lang else None,
             "subject":self.subject if self.subject else None,
             "text":self.text if self.text else None,
             "attribution": self.attribution if self.attribution else None
         }
+        return Serialization.serialize_dict(note_dict)
     
     def __eq__(self, other):
         if not isinstance(other, Note):

gedcomx/OnlineAccount.py

@@ -1,10 +1,10 @@
 from typing import Optional
 
-from .URI import URI
+from .Resource import Resource
 
 class OnlineAccount:
     identifier = 'http://gedcomx.org/v1/OnlineAccount'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, serviceHomepage: URI, accountName: str) -> None:
+    def __init__(self, serviceHomepage: Resource, accountName: str) -> None:
         pass