gedcom-x 0.5__py3-none-any.whl

gedcomx/Gender.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Optional
+
+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 .Conclusion import Conclusion
+from .Qualifier import Qualifier
+
+class GenderType(Enum):
+    Male = "http://gedcomx.org/Male"
+    Female = "http://gedcomx.org/Female"
+    Unknown = "http://gedcomx.org/Unknown"
+    Intersex = "http://gedcomx.org/Intersex"
+    
+    @property
+    def description(self):
+        descriptions = {
+            GenderType.Male: "Male gender.",
+            GenderType.Female: "Female gender.",
+            GenderType.Unknown: "Unknown gender.",
+            GenderType.Intersex: "Intersex (assignment at birth)."
+        }
+        return descriptions.get(self, "No description available.")
+    
+class Gender(Conclusion):
+    identifier = 'http://gedcomx.org/v1/Gender'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,
+                 id: Optional[str] = None,
+                 lang: Optional[str] = 'en',
+                 sources: Optional[List[SourceReference]] = [],
+                 analysis: Optional[URI] = None,
+                 notes: Optional[List[Note]] = [],
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None, 
+                 type: GenderType = None
+                 ) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        self.type = type
+    
+    @classmethod
+    def _from_json_(cls,json_text):
+        return Gender()

gedcomx/Group.py

@@ -0,0 +1,37 @@
+from enum import Enum
+from typing import List, Optional
+
+from .Attribution import Attribution
+from .Conclusion import ConfidenceLevel
+from .Date import Date
+from .EvidenceReference import EvidenceReference
+from .Identifier import Identifier
+from .Note import Note
+from .PlaceReference import PlaceReference
+from .SourceReference import SourceReference
+from .URI import URI
+
+from .TextValue import TextValue
+from .Subject import Subject
+
+class GroupRoleType(Enum):
+    def __init__(self) -> None:
+        super().__init__()
+
+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:
+        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,
+                 names: TextValue,
+                 date: Optional[Date],
+                 place: Optional[PlaceReference],
+                 roles: Optional[List[GroupRole]]) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)

gedcomx/Identifier.py

@@ -0,0 +1,89 @@
+
+from enum import Enum
+
+from typing import List, Optional, Dict, Any
+
+from .Qualifier import Qualifier
+from .URI import URI
+
+class IdentifierType(Enum):
+    Primary = "http://gedcomx.org/Primary"
+    Authority = "http://gedcomx.org/Authority"
+    Deprecated = "http://gedcomx.org/Deprecated"
+    Persistant = "http://gedcomx.org/Persistent"
+    
+    @property
+    def description(self):
+        descriptions = {
+            IdentifierType.Primary: (
+                "The primary identifier for the resource. The value of the identifier MUST resolve to the instance of "
+                "Subject to which the identifier applies."
+            ),
+            IdentifierType.Authority: (
+                "An identifier for the resource in an external authority or other expert system. The value of the identifier "
+                "MUST resolve to a public, authoritative source for information about the Subject to which the identifier applies."
+            ),
+            IdentifierType.Deprecated: (
+                "An identifier that has been relegated, deprecated, or otherwise downgraded. This identifier is commonly used "
+                "as the result of a merge when what was once a primary identifier for a resource is no longer the primary identifier. "
+                "The value of the identifier MUST resolve to the instance of Subject to which the identifier applies."
+            )
+        }
+        return descriptions.get(self, "No description available.")
+    
+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
+        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
+
+        
+        identifier_fields = {
+            'value': self.value if self.value else None,
+            'type': self.type.value if self.type else None
+                           
+        }
+
+        # Serialize and exclude None values
+        for key, value in identifier_fields.items():
+            if value is not None:
+                identifier_fields[key] = _serialize(value)
+
+        return identifier_fields
+
+    @classmethod
+    def _from_json_(cls, data: Dict[str, Any]) -> 'Identifier':
+        """
+        Construct an Identifier from a dict parsed from JSON.
+        """
+        # Parse value (URI dict or string)
+        
+        for key in data.keys():
+            type = key
+            value = data[key]
+        uri_obj: Optional[URI] = None
+        # TODO DO THIS BETTER
+
+        # Parse type
+        raw_type = data.get('type')
+        id_type: Optional[IdentifierType] = IdentifierType(raw_type)
+        
+
+        return cls(value=value, type=id_type)

gedcomx/Name.py

@@ -0,0 +1,241 @@
+from enum import Enum
+from typing import List,Optional
+
+from .Attribution import Attribution
+from .Conclusion import Conclusion, ConfidenceLevel
+from .Date import Date
+from .Note import Note
+from .SourceReference import SourceReference
+from .URI import URI
+
+
+class NameType(Enum):
+    BirthName = "http://gedcomx.org/BirthName"
+    MarriedName = "http://gedcomx.org/MarriedName"
+    AlsoKnownAs = "http://gedcomx.org/AlsoKnownAs"
+    Nickname = "http://gedcomx.org/Nickname"
+    AdoptiveName = "http://gedcomx.org/AdoptiveName"
+    FormalName = "http://gedcomx.org/FormalName"
+    ReligiousName = "http://gedcomx.org/ReligiousName"
+    
+    @property
+    def description(self):
+        descriptions = {
+            NameType.BirthName: "Name given at birth.",
+            NameType.MarriedName: "Name accepted at marriage.",
+            NameType.AlsoKnownAs: "\"Also known as\" name.",
+            NameType.Nickname: "Nickname.",
+            NameType.AdoptiveName: "Name given at adoption.",
+            NameType.FormalName: "A formal name, usually given to distinguish it from a name more commonly used.",
+            NameType.ReligiousName: "A name given at a religious rite or ceremony."
+        }
+        return descriptions.get(self, "No description available.")
+
+class NamePartQualifier(Enum):
+    Title = "http://gedcomx.org/Title"
+    Primary = "http://gedcomx.org/Primary"
+    Secondary = "http://gedcomx.org/Secondary"
+    Middle = "http://gedcomx.org/Middle"
+    Familiar = "http://gedcomx.org/Familiar"
+    Religious = "http://gedcomx.org/Religious"
+    Family = "http://gedcomx.org/Family"
+    Maiden = "http://gedcomx.org/Maiden"
+    Patronymic = "http://gedcomx.org/Patronymic"
+    Matronymic = "http://gedcomx.org/Matronymic"
+    Geographic = "http://gedcomx.org/Geographic"
+    Occupational = "http://gedcomx.org/Occupational"
+    Characteristic = "http://gedcomx.org/Characteristic"
+    Postnom = "http://gedcomx.org/Postnom"
+    Particle = "http://gedcomx.org/Particle"
+    RootName = "http://gedcomx.org/RootName"
+    
+    @property
+    def description(self):
+        descriptions = {
+            NamePartQualifier.Title: "A designation for honorifics (e.g., Dr., Rev., His Majesty, Haji), ranks (e.g., Colonel, General), positions (e.g., Count, Chief), or other titles (e.g., PhD, MD). Name part qualifiers of type Title SHOULD NOT provide a value.",
+            NamePartQualifier.Primary: "A designation for the most prominent name among names of that type (e.g., the primary given name). Name part qualifiers of type Primary SHOULD NOT provide a value.",
+            NamePartQualifier.Secondary: "A designation for a name that is not primary in its importance among names of that type. Name part qualifiers of type Secondary SHOULD NOT provide a value.",
+            NamePartQualifier.Middle: "Useful for cultures designating a middle name distinct from a given name and surname. Name part qualifiers of type Middle SHOULD NOT provide a value.",
+            NamePartQualifier.Familiar: "A designation for one's familiar name. Name part qualifiers of type Familiar SHOULD NOT provide a value.",
+            NamePartQualifier.Religious: "A name given for religious purposes. Name part qualifiers of type Religious SHOULD NOT provide a value.",
+            NamePartQualifier.Family: "A name that associates a person with a group, such as a clan, tribe, or patriarchal hierarchy. Name part qualifiers of type Family SHOULD NOT provide a value.",
+            NamePartQualifier.Maiden: "Original surname retained by women after adopting a new surname upon marriage. Name part qualifiers of type Maiden SHOULD NOT provide a value.",
+            NamePartQualifier.Patronymic: "A name derived from a father or paternal ancestor. Name part qualifiers of type Patronymic SHOULD NOT provide a value.",
+            NamePartQualifier.Matronymic: "A name derived from a mother or maternal ancestor. Name part qualifiers of type Matronymic SHOULD NOT provide a value.",
+            NamePartQualifier.Geographic: "A name derived from associated geography. Name part qualifiers of type Geographic SHOULD NOT provide a value.",
+            NamePartQualifier.Occupational: "A name derived from one's occupation. Name part qualifiers of type Occupational SHOULD NOT provide a value.",
+            NamePartQualifier.Characteristic: "A name derived from a characteristic. Name part qualifiers of type Characteristic SHOULD NOT provide a value.",
+            NamePartQualifier.Postnom: "A name mandated by law for populations in specific regions. Name part qualifiers of type Postnom SHOULD NOT provide a value.",
+            NamePartQualifier.Particle: "A grammatical designation for articles, prepositions, conjunctions, and other words used as name parts. Name part qualifiers of type Particle SHOULD NOT provide a value.",
+            NamePartQualifier.RootName: "The 'root' of a name part, as distinguished from prefixes or suffixes (e.g., the root of 'Wilkówna' is 'Wilk'). A RootName qualifier MUST provide a value property."
+        }
+        return descriptions.get(self, "No description available.")
+
+class NamePartType(Enum):
+    Prefix = "http://gedcomx.org/Prefix"
+    Suffix = "http://gedcomx.org/Suffix"
+    Given = "http://gedcomx.org/Given"
+    Surname = "http://gedcomx.org/Surname"
+    
+    @property
+    def description(self):
+        descriptions = {
+            NamePartType.Prefix: "A name prefix.",
+            NamePartType.Suffix: "A name suffix.",
+            NamePartType.Given: "A given name.",
+            NamePartType.Surname: "A surname."
+        }
+        return descriptions.get(self, "No description available.")
+    
+class NamePart:
+    identifier = 'http://gedcomx.org/v1/NamePart'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,
+                 type: Optional[NamePartType] = None,
+                 value: Optional[str] = None,
+                 qualifiers: Optional[List[NamePartQualifier]] = []) -> None:
+        self.type = type
+        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 __eq__(self, other):
+        if not isinstance(other, NamePart):
+            return NotImplemented
+        return (self.type == other.type and
+                self.value == other.value and
+                self.qualifiers == other.qualifiers)    
+
+class NameForm:
+    identifier = 'http://gedcomx.org/v1/NameForm'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, lang: Optional[str] = 'en', fullText: Optional[str] = None,parts: Optional[List[NamePart]] = []) -> None:
+        self.lang = lang
+        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]}
+    
+    def _fulltext_parts(self):
+        pass
+
+class Name(Conclusion):
+    identifier = 'http://gedcomx.org/v1/Name'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    @staticmethod
+    def simple(text: str):
+        """
+        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]
+        
+        # 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)
+
+        name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
+        name = Name(type=NameType.BirthName,nameForms=[name_form])
+        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,
+                 type: Optional[NameType] = None,
+                 nameForms: NameForm = [],
+                 date: Optional[Date] = None) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        self.type = type
+        self.nameForms = nameForms
+        self.date = date
+    
+    def _add_name_part(self, namepart_to_add: NamePart):
+        if namepart_to_add and isinstance(namepart_to_add, NamePart):
+            for current_namepart in self.nameForms[0].parts:
+                if namepart_to_add == current_namepart:
+                    return False
+            self.nameForms[0].parts.append(namepart_to_add)
+    
+    @property
+    def _as_dict_(self):
+        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})
+        return name_as_dict
+
+def ensure_list(val):
+    if val is None:
+        return []
+    return val if isinstance(val, list) else [val]
+    
+NamePart._from_json_ = classmethod(lambda cls, data: NamePart(
+    type=NamePartType(data['type']) if 'type' in data else None,
+    value=data.get('value'),
+    qualifiers=[NamePartQualifier(q) for q in ensure_list(data.get('qualifiers'))]
+))
+
+NamePart._to_dict_ = lambda self: {
+    'type': self.type.value if self.type else None,
+    'value': self.value,
+    'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
+}
+
+
+# NameForm
+NameForm._from_json_ = classmethod(lambda cls, data: NameForm(
+    lang=data.get('lang', 'en'),
+    fullText=data.get('fullText'),
+    parts=[NamePart._from_json_(p) for p in ensure_list(data.get('parts'))]
+))
+
+NameForm._to_dict_ = lambda self: {
+    'lang': self.lang,
+    'fullText': self.fullText,
+    'parts': [p._to_dict_() for p in self.parts] if self.parts else []
+}
+
+
+# Name
+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,
+    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,
+    type=NameType(data['type']) if data.get('type') else None,
+    nameForms=[NameForm._from_json_(nf) for nf in ensure_list(data.get('nameForms'))],
+    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

@@ -0,0 +1,65 @@
+from typing import Optional
+
+from .Attribution import Attribution
+
+class Note:
+    identifier = 'http://gedcomx.org/v1/Note'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,lang: Optional[str] = 'en', subject: Optional[str] = None, text: Optional[str] = None, attribution: Optional[Attribution] = None) -> None:
+        self.lang = lang
+        self.subject = subject
+        self.text = text
+        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:
+            raise ValueError("The text to add must be a non-empty string.")
+    
+    @property
+    def _as_dict_(self):
+        return {
+            "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
+        }
+    
+    def __eq__(self, other):
+        if not isinstance(other, Note):
+            return NotImplemented
+
+        def safe_str(val):
+            return val.strip() if isinstance(val, str) else ''
+
+        return (
+            #safe_str(self.lang) == safe_str(other.lang) and
+            #safe_str(self.subject) == safe_str(other.subject) and
+            safe_str(self.text) == safe_str(other.text) #and
+           # self.attribution == other.attribution  # Assumes Attribution defines __eq__
+        )
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Note instance from a JSON-dict (already parsed).
+        """
+        # Basic scalar fields
+        lang     = data.get('lang', 'en')
+        text     = data.get('text')
+        subject  = data.get('subject')
+        # Add other fields as needed
+
+        # Build the instance
+        inst = cls(
+            lang    = lang,
+            text    = text,
+            subject = subject,
+            # Add other fields as needed
+        )
+
+        return inst

gedcomx/OnlineAccount.py

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

gedcomx/Person.py

@@ -0,0 +1,178 @@
+from enum import Enum
+from typing import List, Optional
+
+from .Attribution import Attribution
+from .Conclusion import ConfidenceLevel
+from .EvidenceReference import EvidenceReference
+from .Fact import Fact
+from .Gender import Gender, GenderType
+from .Identifier import Identifier
+from .Name import Name, NameForm, NamePart, NamePartType, NamePartQualifier
+from .Note import Note
+from .SourceReference import SourceReference
+from .Subject import Subject
+from .URI import URI
+
+class Person(Subject):
+    identifier = 'http://gedcomx.org/v1/Person'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, id: str = None,
+             lang: str = 'en',
+             sources: Optional[List[SourceReference]] = None,
+             analysis: Optional[URI] = None,
+             notes: Optional[List[Note]] = None,
+             confidence: Optional[ConfidenceLevel] = None,
+             attribution: Optional[Attribution] = None,
+             extracted: bool = None,
+             evidence: Optional[List[EvidenceReference]] = None,
+             media: Optional[List[SourceReference]] = None,
+             identifiers: Optional[List[Identifier]] = None,
+             private: Optional[bool] = False,
+             gender: Optional[Gender] = Gender(type=GenderType.Unknown),
+             names: Optional[List[Name]] = None,
+             facts: Optional[List[Fact]] = None,
+             living: Optional[bool] = False) -> None:
+        # Call superclass initializer if needed
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
+        
+        # Initialize mutable attributes to empty lists if None
+        self.sources = sources if sources is not None else []
+        self.notes = notes if notes is not None else []
+        self.evidence = evidence if evidence is not None else []
+        self.media = media if media is not None else []
+        self.identifiers = identifiers if identifiers is not None else []
+        self.names = names if names is not None else []
+        self.facts = facts if facts is not None else []
+
+        self.private = private
+        self.gender = gender
+
+        self.living = living       #TODO This is from familysearch API
+
+        self._relationships = []
+        
+    
+    def add_fact(self, fact_to_add: Fact) -> bool:
+        if fact_to_add and isinstance(fact_to_add,Fact):
+            for current_fact in self.facts:
+                if fact_to_add == current_fact:
+                    return False
+            self.facts.append(fact_to_add)
+            return True
+
+    def add_name(self, name_to_add: Name) -> bool:
+        if len(self.names) > 5: 
+            for name in self.names:
+                print(name)
+            raise
+        if name_to_add and isinstance(name_to_add, Name):
+            for current_name in self.names:
+                if name_to_add == current_name:
+                    return False
+            self.names.append(name_to_add)
+            return True
+    
+    def _add_relationship(self, relationship_to_add: object):
+        from .Relationship import Relationship
+        if isinstance(relationship_to_add,Relationship):
+            self._relationships.append(relationship_to_add)
+        else:
+            raise ValueError()
+    
+    @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
+
+        subject_fields = super()._as_dict_  # Start with base class fields
+        # Only add Relationship-specific fields
+        subject_fields.update({
+            'private': self.private,
+            'living': self.living,
+            'gender': self.gender.type.value if self.gender.type else None,
+            'names': [name for name in self.names],
+            'facts': [fact for fact in self.facts]
+                           
+        })
+
+        # Serialize and exclude None values
+        for key, value in subject_fields.items():
+            if value is not None:
+                subject_fields[key] = _serialize(value)
+
+        return subject_fields
+    
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        def ensure_list(value):
+            if value is None:
+                return []
+            if isinstance(value, list):
+                return value
+            return [value]  # wrap single item in list
+        
+        # Basic scalar fields
+        id_        = data.get('id')
+        lang       = data.get('lang', 'en')
+        private    = data.get('private', False)
+        extracted  = data.get('extracted', False)
+
+        living  = data.get('extracted', False)
+
+        # Complex singletons
+        analysis    = URI._from_json_(data['analysis']) if data.get('analysis') else None
+        attribution = Attribution._from_json_(data['attribution']) if data.get('attribution') else None
+        confidence  = ConfidenceLevel._from_json_(data['confidence']) if data.get('confidence') else None
+
+        # Gender (string or dict depending on your JSON)
+        gender_json = data.get('gender')
+        if isinstance(gender_json, dict):
+            gender = Gender._from_json_(gender_json)
+        else:
+            # if it's just the enum value
+            gender = Gender(type=GenderType(gender_json)) if gender_json else Gender(type=GenderType.Unknown)
+        
+        
+        sources     = [SourceReference._from_json_(o)   for o in ensure_list(data.get('sources'))]
+        notes       = [Note._from_json_(o)              for o in ensure_list(data.get('notes'))]
+        evidence    = [EvidenceReference._from_json_(o) for o in ensure_list(data.get('evidence'))]
+        media       = [SourceReference._from_json_(o)   for o in ensure_list(data.get('media'))]
+        identifiers = [Identifier._from_json_(o)        for o in ensure_list(data.get('identifiers'))]
+        names       = [Name._from_json_(o)              for o in ensure_list(data.get('names'))]
+        facts       = [Fact._from_json_(o)              for o in ensure_list(data.get('facts'))]
+
+        # Build the instance
+        inst = cls(
+            id          = id_,
+            lang        = lang,
+            sources     = sources,
+            analysis    = analysis,
+            notes       = notes,
+            confidence  = confidence,
+            attribution = attribution,
+            extracted   = extracted,
+            evidence    = evidence,
+            media       = media,
+            identifiers = identifiers,
+            private     = private,
+            gender      = gender,
+            names       = names,
+            facts       = facts,
+            living      = living
+        )
+
+        return inst