gedcom-x 0.5__py3-none-any.whl

gedcomx/PlaceDescription.py

@@ -0,0 +1,47 @@
+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 .SourceReference import SourceReference
+from .TextValue import TextValue
+from .URI import URI
+
+from .Subject import Subject
+
+class PlaceDescription(Subject):
+    identifier = "http://gedcomx.org/v1/PlaceDescription"
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    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,
+                 extracted: bool = None,
+                 evidence: List[EvidenceReference] = None,
+                 media: List[SourceReference] = [],
+                 identifiers: List[Identifier] = [],
+                 names: List[TextValue] = [],
+                 type: Optional[str] = None,
+                 place: Optional[URI] = None,
+                 jurisdiction: Optional["PlaceDescription"] = None, # PlaceDescription
+                 latitude: Optional[float] = None,
+                 longitude: Optional[float] = None,
+                 temporalDescription: Optional[Date] = None,
+                 spatialDescription: Optional[URI] = None,) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
+        self.names = names
+        self.type = type
+        self.place = place
+        self.jurisdiction = jurisdiction
+        self.latitide = latitude
+        self.longitute = longitude
+        self.temporalDescription = temporalDescription
+        self.spacialDescription = spatialDescription
+
+        

gedcomx/PlaceReference.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from .URI import URI
+
+class PlaceReference:
+    identifier = 'http://gedcomx.org/v1/PlaceReference'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+    
+    def __init__(self, original: Optional[str], descriptionRef: Optional[URI]) -> None:
+        self.original = original
+        self.descriptionRef = descriptionRef
+
+    @property
+    def _as_dict_(self):
+        return {
+            'original': self.original,
+            'descriptionRef': self.descriptionRef._as_dict_ if self.descriptionRef else None
+            } 
+
+def ensure_list(val):
+    if val is None:
+        return []
+    return val if isinstance(val, list) else [val]
+
+# PlaceReference
+PlaceReference._from_json_ = classmethod(lambda cls, data: PlaceReference(
+    original=data.get('original'),
+    descriptionRef=URI._from_json_(data['description']) if data.get('description') else None
+))
+
+   

gedcomx/Qualifier.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+class Qualifier:
+    identifier = 'http://gedcomx.org/v1/Qualifier'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+    
+    def __init__(self, name: str, value: Optional[str]) -> None:
+        self.name = name
+        self.value = value
+    
+    @property
+    def __as_dict__(self):
+        from .Serialization import serialize_to_dict
+
+        data =  {
+            "name":self.name if self.name else None,
+            "value":self.value if self.value else None
+        }
+
+        return serialize_to_dict(data,False)
+    
+    # Qualifier
+Qualifier._from_json_ = classmethod(lambda cls, data: Qualifier(
+    name=data.get('name'),
+    value=data.get('value')
+))
+

gedcomx/Relationship.py

@@ -0,0 +1,116 @@
+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 .Identifier import Identifier
+from .Note import Note
+from .Person import Person
+from .Serialization import serialize_to_dict
+from .SourceReference import SourceReference
+from .URI import URI
+
+from .Subject import Subject
+
+class RelationshipType(Enum):
+    Couple = "http://gedcomx.org/Couple"
+    ParentChild = "http://gedcomx.org/ParentChild"
+    
+    @property
+    def description(self):
+        descriptions = {
+            RelationshipType.Couple: "A relationship of a pair of persons.",
+            RelationshipType.ParentChild: "A relationship from a parent to a child."
+        }
+        return descriptions.get(self, "No description available.")
+    
+class Relationship(Subject):
+    identifier = 'http://gedcomx.org/v1/Relationship'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, 
+             id: Optional[str] = None,
+             lang: Optional[str] = None,
+             sources: Optional[List[SourceReference]] = None,
+             analysis: Optional[URI] = None,
+             notes: Optional[List[Note]] = None,
+             confidence: Optional[ConfidenceLevel] = None,
+             attribution: Optional[Attribution] = None,
+             extracted: Optional[bool] = None,
+             evidence: Optional[List[EvidenceReference]] = None,
+             media: Optional[List[SourceReference]] = None,
+             identifiers: Optional[List[Identifier]] = None,
+             type: Optional[RelationshipType] = None,
+             person1: Optional[URI] = None,
+             person2: Optional[URI] = None,
+             facts: Optional[List[Fact]] = None) -> None:
+    
+        # Call superclass initializer if required
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
+        
+        # Initialize optional parameters with default 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.facts = facts if facts is not None else []
+
+        # Initialize other attributes
+        self.type = type
+        self.person1 = person1
+        self.person2 = person2
+        self.facts = facts if facts else None
+    
+    @property
+    def _as_dict_(self):
+        return serialize_to_dict(self, {
+            "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
+            "person1": self.person1._uri,
+            "person2": self.person2._uri,
+            "facts": [fact for fact in self.facts] if self.facts else None
+        })
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Relationship 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 (adjust as needed)
+        id_        = data.get('id')
+        type_      = data.get('type')
+        extracted  = data.get('extracted', None)
+        private    = data.get('private', None)
+
+        # Complex singletons (adjust as needed)
+        person1    = URI.from_url(data.get('person1')['resource']) if data.get('person1') else None
+        person2    = URI.from_url(data.get('person2')['resource']) if data.get('person2') else None
+        facts      = [Fact._from_json_(o) for o in ensure_list(data.get('facts'))]
+        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'))]
+
+        # Build the instance
+        inst = cls(
+            id        = id_,
+            type      = type_,
+            extracted = extracted,
+            #private   = private,       #TODO Has this been added?
+            person1   = person1,
+            person2   = person2,
+            facts     = facts,
+            sources   = sources,
+            notes     = notes
+        )
+
+        return inst
+
+    

gedcomx/Serialization.py

@@ -0,0 +1,37 @@
+from typing import Dict
+
+
+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

gedcomx/SourceCitation.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+class SourceCitation:
+    identifier = 'http://gedcomx.org/v1/SourceCitation'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+    
+    def __init__(self, lang: Optional[str], value: str) -> None:
+        self.lang = lang if lang else 'en'
+        self.value = value
+    
+    # ...existing code...
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a SourceCitation instance from a JSON-dict (already parsed).
+        """
+        lang = data.get('lang', 'en')
+        value = data.get('value')
+        return cls(lang=lang, value=value)

gedcomx/SourceDescription.py

@@ -0,0 +1,241 @@
+import base64
+import uuid
+import warnings
+
+from enum import Enum
+from typing import List, Optional, Dict, Any
+
+from .Agent import Agent
+from .Attribution import Attribution
+from .Coverage import Coverage
+from .Date import Date
+from .Identifier import Identifier
+from .Note import Note
+from .SourceCitation import SourceCitation
+from .SourceReference import SourceReference
+from .TextValue import TextValue
+from .URI import URI
+
+class ResourceType(Enum):
+    Collection = "http://gedcomx.org/Collection"
+    PhysicalArtifact = "http://gedcomx.org/PhysicalArtifact"
+    DigitalArtifact = "http://gedcomx.org/DigitalArtifact"
+    Record = "http://gedcomx.org/Record"
+    
+    @property
+    def description(self):
+        descriptions = {
+            ResourceType.Collection: "A collection of genealogical resources. A collection may contain physical artifacts (such as a collection of books in a library), records (such as the 1940 U.S. Census), or digital artifacts (such as an online genealogical application).",
+            ResourceType.PhysicalArtifact: "A physical artifact, such as a book.",
+            ResourceType.DigitalArtifact: "A digital artifact, such as a digital image of a birth certificate or other record.",
+            ResourceType.Record: "A historical record, such as a census record or a vital record."
+        }
+        return descriptions.get(self, "No description available.")
+    
+class SourceDescription:
+    identifier = "http://gedcomx.org/v1/SourceDescription"
+
+    def __init__(self, id: Optional[str] = None,
+                 resourceType: Optional[ResourceType] = None,
+                 citations: Optional[List[SourceCitation]] = [],
+                 mediaType: Optional[str] = None,
+                 about: Optional[URI] = None,
+                 mediator: Optional[URI] = None,
+                 publisher: Optional[URI] = None,
+                 authors: Optional[List[URI]] = [],
+                 sources: List[SourceReference] = [], # SourceReference
+                 analysis: Optional[URI] = None,  # analysis should be of type 'Document', not specified to avoid circular import
+                 componentOf: Optional[SourceReference] = None, # SourceReference
+                 titles: Optional[List[TextValue]] = [],
+                 notes: Optional[List[Note]] = [],
+                 attribution: Optional[Attribution] = None,
+                 rights: Optional[List[URI]] = [],
+                 coverage: Optional[Coverage] = None, # Coverage
+                 descriptions: Optional[List[TextValue]] = [],
+                 identifiers: Optional[List[Identifier]] = [],
+                 created: Optional[Date] = None,
+                 modified: Optional[Date] = None,
+                 published: Optional[Date] = None,
+                 repository: Optional[Agent] = None,
+                 max_note_count: int = 20):
+        
+        self.id = id if id else SourceDescription.default_id_generator()
+        self.resourceType = resourceType
+        self.citations = citations or []
+        self.mediaType = mediaType
+        self.about = about
+        self.mediator = mediator
+        self.publisher = publisher
+        self.authors = authors or []
+        self.source_refs = sources or []
+        self.analysis = analysis
+        self.componentOf = componentOf
+        self.titles = titles or []
+        self.notes = notes or []
+        self.attribution = attribution
+        self.rights = rights or []
+        self.coverage = coverage or []
+        self.descriptions = descriptions or []
+        self.identifiers = identifiers or []
+        self.created = created
+        self.modified = modified
+        self.published = published
+        self.repository = repository
+        self.max_note_count = max_note_count
+
+        self._uri = URI(fragment=id)
+    
+    def add_description(self, desccription_to_add: TextValue):
+        if desccription_to_add and isinstance(desccription_to_add,TextValue):
+            for current_description in self.descriptions:
+                if desccription_to_add == current_description:
+                    return
+            self.descriptions.append(desccription_to_add)
+
+    def add_identifier(self, identifier_to_add: Identifier):
+        if identifier_to_add and isinstance(identifier_to_add,Identifier):
+            for current_identifier in self.identifiers:
+                if identifier_to_add == current_identifier:
+                    return
+            self.identifiers.append(identifier_to_add)
+    
+    def add_note(self,note_to_add: Note):
+        if 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):
+            for existing in self.notes:
+                if note_to_add == existing:
+                    return False
+            self.notes.append(note_to_add)
+    
+    def add_source(self, source_to_add: object):
+        #from .SourceReference import SourceReference
+        if source_to_add and isinstance(object,SourceReference):
+            for current_source in self.sources:
+                if current_source == source_to_add:
+                    return
+            self.sources.append(source_to_add)
+
+    def add_title(self, title_to_add: TextValue):
+        if isinstance(title_to_add,str): title_to_add = TextValue(value=title_to_add)
+        if title_to_add and isinstance(title_to_add, TextValue):
+            for current_title in self.titles:
+                if title_to_add == current_title:
+                    return False
+            self.titles.append(title_to_add)
+        else:
+            raise ValueError(f"Cannot add title of type {type(title_to_add)}")
+        
+    @staticmethod
+    def default_id_generator():
+        # Generate a standard UUID
+        standard_uuid = uuid.uuid4()
+        # Convert UUID to bytes
+        uuid_bytes = standard_uuid.bytes
+        # Encode bytes to a Base64 string
+        short_uuid = base64.urlsafe_b64encode(uuid_bytes).rstrip(b'=').decode('utf-8')
+        return 'SD-' + str(short_uuid)
+    
+    @property
+    def _as_dict_(self) -> Dict[str, Any]:
+        def _serialize(val: Any) -> Any:
+            if hasattr(val, '_as_dict_'):
+                return val._as_dict_
+            if isinstance(val, URI):
+                return val._prop_dict()
+            if isinstance(val, Enum):
+                return val.value
+            if isinstance(val, (str, int, float, bool)) or val is None:
+                return val
+            if isinstance(val, list):
+                return [_serialize(v) for v in val]
+            if isinstance(val, dict):
+                return {k: _serialize(v) for k, v in val.items()}
+            return str(val)
+
+        data = {
+            'id': self.id,
+            'resourceType': self.resourceType.value if self.resourceType else None,
+            'citations': [c._as_dict_ for c in self.citations] or None,
+            'mediaType': self.mediaType,
+            'about': self.about._prop_dict() if self.about else None,
+            'mediator': self.mediator._prop_dict() if self.mediator else None,
+            'publisher': self.publisher._prop_dict() if self.publisher else None,
+            'authors': [a._prop_dict() for a in self.authors] or None,
+            'sources': [s._as_dict_ for s in self.sources] or None,
+            'analysis': self.analysis._prop_dict() if self.analysis else None,
+            'componentOf': self.componentOf._as_dict_ if self.componentOf else None,
+            'titles': [t._prop_dict() for t in self.titles] or None,
+            'notes': [n._prop_dict() for n in self.notes] or None,
+            'attribution': self.attribution._as_dict_ if self.attribution else None,
+            'rights': [r._prop_dict() for r in self.rights] or None,
+            'coverage': self.coverage._as_dict_ if self.coverage else None,
+            'descriptions': [d._prop_dict() for d in self.descriptions] or None,
+            'identifiers': [i._as_dict_ for i in self.identifiers] or None,
+            'created': self.created._prop_dict() if self.created else None,
+            'modified': self.modified._prop_dict() if self.modified else None,
+            'published': self.published._prop_dict() if self.published else None,
+            'repository': self.repository._prop_dict() if self.repository else None
+        }
+        # Remove None values
+        return {k: v for k, v in data.items() if v is not None}
+    
+    @classmethod
+    def _from_json_(cls, data: Dict[str, Any]) -> 'SourceDescription':
+        print(data,type(data))
+        # TODO Hande Resource/URI
+        
+        # Basic fields
+        id_ = data.get('id')
+        rt = ResourceType(data['resourceType']) if data.get('resourceType') else None
+
+        # Sub-objects
+        citations    = [SourceCitation._from_json_(c) for c in data.get('citations', [])]
+        about        = URI._from_json_(data['about']) if data.get('about') else None
+        mediator     = URI._from_json_(data['mediator']) if data.get('mediator') else None
+        publisher    = Agent._from_json_(data['publisher']) if data.get('publisher') else None
+        authors      = [URI._from_json_(a) for a in data.get('authors', [])]
+        sources      = [SourceReference._from_json_(s) for s in data.get('sources', [])]
+        analysis     = URI._from_json_(data['analysis']) if data.get('analysis') else None
+        component_of = SourceReference._from_json_(data['componentOf']) if data.get('componentOf') else None
+        titles       = [TextValue._from_json_(t) for t in data.get('titles', [])]
+        notes        = [Note._from_json_(n) for n in data.get('notes', [])]
+        attribution  = Attribution._from_json_(data['attribution']) if data.get('attribution') else None
+        rights       = [URI._from_json_(r) for r in data.get('rights', [])]
+        coverage     = [Coverage._from_json_(cvg) for cvg in data.get('coverage',[])] 
+        descriptions = [TextValue._from_json_(d) for d in data.get('descriptions', [])]
+        identifiers  = [Identifier._from_json_(i) for i in data.get('identifiers', [])]
+        created      = Date._from_json_(data['created']) if data.get('created') else None
+        modified     = Date._from_json_(data['modified']) if data.get('modified') else None
+        published    = Date._from_json_(data['published']) if data.get('published') else None
+        repository   = Agent._from_json_(data['repository']) if data.get('repository') else None
+
+        return cls(
+            id=id_, resourceType=rt, citations=citations,
+            mediaType=data.get('mediaType'), about=about,
+            mediator=mediator, publisher=publisher,
+            authors=authors, sources=sources,
+            analysis=analysis, componentOf=component_of,
+            titles=titles, notes=notes, attribution=attribution,
+            rights=rights, coverage=coverage,
+            descriptions=descriptions, identifiers=identifiers,
+            created=created, modified=modified,
+            published=published, repository=repository
+        )
+
+    @property
+    def publisher(self) -> URI:
+        if not self._publisher is None or isinstance(self._publisher,URI): assert False
+        return self._publisher
+
+    @publisher.setter
+    def publisher(self, value: URI | Agent):
+        if value is None:
+            self._publisher = None
+        elif isinstance(value,URI):
+            assert False
+        elif isinstance(value,Agent):
+            self._publisher = value._uri
+        else:
+            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")