gedcom-x 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

gedcomx/Coverage.py

@@ -1,37 +0,0 @@
-from typing import Optional
-
-from .Date import Date
-from .PlaceReference import PlaceReference
-
-
-class Coverage:
-    identifier = 'http://gedcomx.org/v1/Coverage'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self,spatial: Optional[PlaceReference], temporal: Optional[Date]) -> None:
-        self.spatial = spatial
-        self.temporal = temporal    
-    
-    # ...existing code...
-
-    @property
-    def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dict = {}
-        if self.spatial:
-            type_as_dict['spatial'] = getattr(self.spatial, '_as_dict_', self.spatial)
-        if self.temporal:  # (fixed: no space after the dot)
-            type_as_dict['temporal'] = getattr(self.temporal, '_as_dict_', self.temporal)
-        return Serialization.serialize_dict(type_as_dict) 
-
-    @classmethod
-    def _from_json_(cls, data: dict):
-        """
-        Create a Coverage instance from a JSON-dict (already parsed).
-        """
-        from .PlaceReference import PlaceReference
-        from .Date import Date
-
-        spatial = PlaceReference._from_json_(data.get('spatial')) if data.get('spatial') else None
-        temporal = Date._from_json_(data.get('temporal')) if data.get('temporal') else None
-        return cls(spatial=spatial, temporal=temporal)

gedcomx/EvidenceReference.py

@@ -1,11 +0,0 @@
-from typing import Optional
-
-from .Attribution import Attribution
-from .Resource import Resource
-
-class EvidenceReference:
-    identifier = 'http://gedcomx.org/v1/EvidenceReference'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self, resource: Resource, attribution: Optional[Attribution]) -> None:
-        pass

gedcomx/Gender.py

@@ -1,65 +0,0 @@
-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.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"
-    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] = None,
-                 sources: Optional[List[SourceReference]] = None,
-                 analysis: Optional[Resource] = None,
-                 notes: Optional[List[Note]] = None,
-                 confidence: Optional[ConfidenceLevel] = None,
-                 attribution: Optional[Attribution] = None, 
-                 type: Optional[GenderType] = None
-                 ) -> None:
-        super().__init__(id=id, lang=lang, sources=sources, analysis=analysis, notes=notes, confidence=confidence, attribution=attribution)
-        self.type = type
-    
-    @property
-    def _as_dict_(self):
-        from .Serialization import Serialization    
-        type_as_dict = super()._as_dict_  
-        if self.type:
-            type_as_dict['type'] = self.type.value if self.type else None                   
-        
-        
-        return Serialization.serialize_dict(type_as_dict)
-
-    @classmethod
-    def _from_json_(cls,data):
-        from .Serialization import Serialization
-        
-        return Serialization.deserialize(data, Gender)
-        
-        

gedcomx/Group.py

@@ -1,37 +0,0 @@
-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 .Resource import Resource
-
-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: 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: 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],
-                 roles: Optional[List[GroupRole]]) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)

gedcomx/Note.py

@@ -1,73 +0,0 @@
-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):
-            if self.text:
-                self.text = self.text + text_to_add
-            else:
-                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):
-        from .Serialization import Serialization
-        type_as_dict = {}
-        if self.lang:
-            type_as_dict["lang"] = self.lang
-        if self.subject:
-            type_as_dict["subject"] = self.subject
-        if self.text:
-            type_as_dict["text"] = self.text
-        if self.attribution:
-            # If attribution exposes `_as_dict_` as a property, use it; otherwise include as-is
-            type_as_dict["attribution"] = getattr(self.attribution, "_as_dict_", self.attribution)
-        return Serialization.serialize_dict(type_as_dict)    
-    
-    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

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

gedcomx/Relationship.py

@@ -1,97 +0,0 @@
-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 .SourceReference import SourceReference
-from .Resource import Resource
-
-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):
-    """Represents a relationship between two Person(s)
-
-    Args:
-        type (RelationshipType): Type of relationship 
-        person1 (Person) = First Person in Relationship
-        person2 (Person): Second Person in Relationship
-
-    Raises:
-        
-    """
-    identifier = 'http://gedcomx.org/v1/Relationship'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self,
-             person1: Optional[Person | Resource] = None,
-             person2: Optional[Person | Resource] = None,
-             facts: Optional[List[Fact]] = None,  
-             id: Optional[str] = None,
-             lang: Optional[str] = None,
-             sources: Optional[List[SourceReference]] = None,
-             analysis: Optional[Resource] = 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,
-             ) -> None:
-    
-        # Call superclass initializer if required
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
-        
-        self.type = type
-        self.person1 = person1
-        self.person2 = person2
-        self.facts = facts if facts else []
-    
-    def add_fact(self,fact: Fact):
-        if fact is not None and isinstance(fact,Fact):
-            for existing_fact in self.facts:
-                if fact == existing_fact:
-                    return
-            self.facts.append(fact)
-        else:
-            raise TypeError(f"Expected type 'Fact' recieved type {type(fact)}")
-
-    @property
-    def _as_dict_(self):
-        from .Serialization import Serialization
-        type_as_dict = super()._as_dict_
-        type_as_dict.update({
-            "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
-            "person1": Resource(target=self.person1)._as_dict_ if self.person1 else None,
-            "person2": Resource(target=self.person1)._as_dict_ if self.person2 else None,
-            "facts": [fact for fact in self.facts] if self.facts else None
-        })
-        return Serialization.serialize_dict(type_as_dict)
-
-    @classmethod
-    def _from_json_(cls, data: dict):
-        """
-        Create a Person instance from a JSON-dict (already parsed).
-        """
-        from .Serialization import Serialization
-        return Serialization.deserialize(data, Relationship)
-    

gedcomx/Resource.py

@@ -1,85 +0,0 @@
-from typing import Optional
-
-"""
-======================================================================
- Project: Gedcom-X
- File:    Resource.py
- Author:  David J. Cartwright
- Purpose: References TopLevel Types for Serialization
-
- Created: 2025-08-25
- Updated:
-   - 2025-08-31: working on target=Resource and deserialization issues
-   
-======================================================================
-"""
-
-"""
-======================================================================
-GEDCOM Module Types
-======================================================================
-"""
-
-from .URI import URI
-    
-class Resource:
-    """
-    Class used to track and resolve URIs and references between datastores.
-
-    Parameters
-    ----------
-    
-    Raises
-    ------
-    ValueError
-        If `id` is not a valid UUID.
-    """
-    # TODO, Deal with a resouce being passed, as it may be unresolved.
-    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) if isinstance(uri,URI) else URI.from_url(uri) if isinstance(uri,str) else None
-        self.Id = id
-
-        self.type = None
-        self.resolved = False
-        self.target: object = target
-        self.remote: bool | None = None    # is the resource pointed to persitent on a remote datastore?
-
-        if target:
-            if isinstance(target,Resource):
-                self.resource = target.resource
-                self.Id = target.Id
-                self.target = target.target
-            else:
-                self.resource = target.uri
-                self.Id = target.id
-                self.type = type(target)
-   
-    @property
-    def uri(self):
-        return self.resource
-    
-    @property
-    def _as_dict_(self):
-        from .Serialization import Serialization
-        typ_as_dict = {}
-        if self.resource:
-            typ_as_dict['resource'] = self.resource.value if self.resource else None
-        if self.Id:
-            typ_as_dict['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 ''}"
-    
-
-