gedcom-x 0.5__py3-none-any.whl

gedcomx/SourceReference.py

@@ -0,0 +1,168 @@
+from typing import List, Optional
+
+from .Attribution import Attribution
+from .Qualifier import Qualifier
+
+from .URI import URI
+
+class KnownSourceReference(Qualifier):
+    CharacterRegion = "http://gedcomx.org/CharacterRegion"
+    RectangleRegion = "http://gedcomx.org/RectangleRegion"
+    TimeRegion = "http://gedcomx.org/TimeRegion"
+    Page = "http://gedcomx.org/Page"
+    
+    @property
+    def description(self):
+        descriptions = {
+            self.CharacterRegion: (
+                "A region of text in a digital document, in the form of a,b where a is the index of the start "
+                "character and b is the index of the end character. The meaning of this qualifier is undefined "
+                "if the source being referenced is not a digital document."
+            ),
+            self.RectangleRegion: (
+                "A rectangular region of a digital image. The value of the qualifier is interpreted as a series "
+                "of four comma-separated numbers. If all numbers are less than 1, it is interpreted as x1,y1,x2,y2, "
+                "representing percentage-based coordinates of the top-left and bottom-right corners. If any number is "
+                "more than 1, it is interpreted as x,y,w,h where x and y are coordinates in pixels, and w and h are "
+                "the width and height of the rectangle in pixels."
+            ),
+            self.TimeRegion: (
+                "A region of time in a digital audio or video recording, in the form of a,b where a is the starting "
+                "point in milliseconds and b is the ending point in milliseconds. This qualifier's meaning is undefined "
+                "if the source is not a digital audio or video recording."
+            ),
+            self.Page: (
+                "A single page in a multi-page document, represented as a 1-based integer. This always references the "
+                "absolute page number, not any custom page number. This qualifier is undefined if the source is not a "
+                "multi-page document."
+            )
+        }
+        return descriptions.get(self, "No description available.")
+    
+class SourceReference:
+    identifier = 'http://gedcomx.org/v1/SourceReference'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,
+                 description: URI, descriptionId: Optional[str] = None, attribution: Optional[Attribution] = None, qualifiers: Optional[List[Qualifier]] = []) -> 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 = URI(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
+
+    def add_qualifier(self, qualifier: Qualifier):
+        if isinstance(qualifier, Qualifier):
+            self.qualifiers.append(qualifier)
+    
+    def append(self, text_to_add: str):
+        if text_to_add and isinstance(text_to_add, str):
+            if self.descriptionId is None:
+                self.descriptionId = text_to_add
+            else:
+                self.descriptionId += text_to_add
+        else:
+            raise ValueError("The 'text_to_add' must be a non-empty string.")
+    
+    @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_object._uri if self._description_object else None,
+            'descriptionId': self.descriptionId.replace("\n"," ").replace("\r"," ") if self.descriptionId else None,
+            'attribution': self.attribution if self.attribution else None,
+            'qualifiers':[qualifier.value for qualifier in self.qualifiers ] if self.qualifiers else None
+            }
+
+        # Serialize and exclude None values
+        for key, value in sourcereference_fields.items():
+            if value is not None:
+                sourcereference_fields[key] = _serialize(value)
+
+        return sourcereference_fields
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        print(data)
+        
+        """
+        Rehydrate a SourceReference from the dict form produced by _as_dict_.
+        """
+        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'])
+        
+        # 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__):
+            return False  
+
+        return (
+            self.description._uri == other.description._uri
+        )

gedcomx/Subject.py

@@ -0,0 +1,73 @@
+import warnings
+from typing import List, Optional
+
+from .Attribution import Attribution
+from .Conclusion import Conclusion, ConfidenceLevel
+from .EvidenceReference import EvidenceReference
+from .Identifier import Identifier
+from .Note import Note
+from .Serialization import serialize_to_dict
+from .SourceReference import SourceReference
+from .URI import URI
+
+class Subject(Conclusion):
+    identifier = 'http://gedcomx.org/v1/Subject'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,
+                 id: Optional[str],
+                 lang: Optional[str] = 'en',
+                 sources: Optional[List[SourceReference]] = [],
+                 analysis: Optional[URI] = None,
+                 notes: Optional[List[Note]] = [],
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 extracted: Optional[bool] = None,
+                 evidence: Optional[List[EvidenceReference]] = [],
+                 media: Optional[List[SourceReference]] = [],
+                 identifiers: Optional[List[Identifier]] = [],
+                 uri: Optional[URI] = None) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        self.extracted = extracted
+        self.evidence = evidence
+        self.media = media
+        self.identifiers = identifiers
+        
+    
+    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)
+   
+    @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({
+            "extracted": self.extracted,
+            "evidence": [evidence_ref for evidence_ref in self.evidence] if self.evidence else None,
+            "media": [media for media in self.media] if self.media else None,
+            "identifiers": [identifier for identifier in self.identifiers] if self.identifiers else None
+                           
+        })
+
+        # 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

gedcomx/TextValue.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+class TextValue:
+    identifier = 'http://gedcomx.org/v1/TextValue'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, value: Optional[str] = None, lang: Optional[str] = 'en') -> None:
+        self.lang = lang
+        self.value = value
+    
+    def _append_to_value(self, value_to_append):
+        if not isinstance(value_to_append, str):
+            raise ValueError(f"Cannot append object of type {type(value_to_append)}.")
+        self.value += ' ' + value_to_append
+    
+    def _prop_dict(self):
+        return {
+            "lang":self.lang if self.lang else None,
+            "value":self.value if self.value else None
+        }
+    
+    def __str__(self):
+        return f"{self.value} ({self.lang})"
+    
+    # ...existing code...
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a TextValue instance from a JSON-dict (already parsed).
+        """
+        value = data.get('value')
+        lang = data.get('lang', 'en')
+        return cls(value=value, lang=lang)

gedcomx/TopLevelTypeCollection.py

@@ -0,0 +1,47 @@
+from .TextValue import TextValue
+
+class TopLevelTypeCollection:
+    def __init__(self):
+        self.items = {}
+        self.items_by_type = {}
+        self._id_idx ={}     # Hash Table for searching for item by id
+        self._name_idx = {}
+        self._uri_idx = {}
+        self.authority = 'NewGedcomX'
+        self.len = 0
+    
+
+    def append(self, item) -> bool:
+        if item._uri._authority == '' or item._uri._authority is None:
+            item._uri._authority = self.authority
+        if item._uri._path == '' or item._uri._path is None:
+            item._uri._path = f'{item.__class__.__name__}s'
+
+        self.items[item._uri] = item
+        self._update_indexes(item)
+        self.len += 1
+    
+    def _update_indexes(self, item):
+        # Update the id index
+        if hasattr(item, 'id'):
+            self._id_idx[item.id] = item
+        if hasattr(item, 'names'):
+            for name in item.names:
+                if isinstance(name,TextValue):
+                    self._name_idx[name] = item
+                else:
+                    break
+        if item.__class__.__name__ in self.items_by_type.keys():
+            self.items_by_type[item.__class__.__name__].append(item)
+        else:
+            self.items_by_type[item.__class__.__name__] = [item]
+
+    
+    def _dump_uris(self):
+        for uri in self.items.keys():
+            print(uri._uri)
+    
+    def __len__(self):
+        return self.len
+        
+        

gedcomx/URI.py

@@ -0,0 +1,70 @@
+from typing import Optional
+from urllib.parse import urlparse
+
+class URI:
+    @classmethod
+    def from_url(cls, url: str) -> 'URI':
+        parsed_url = urlparse(url)
+        return cls(
+            value=url,
+            scheme=parsed_url.scheme if parsed_url.scheme else 'gedcomx',
+            authority=parsed_url.netloc,
+            path=parsed_url.path,
+            query=parsed_url.query,
+            fragment=parsed_url.fragment
+        )
+    
+    def parse(value: str) -> None:
+        """Parse the URI string and populate attributes."""
+        parsed = urlparse(value)
+        return URI(scheme=parsed.scheme,authority = parsed.netloc, path = parsed.path, query = parsed.query, fragment = parsed.fragment)
+        
+
+    def __init__(self, value: Optional[str] = None,
+                 scheme: Optional[str] = None,
+                 authority: Optional[str] = None,
+                 path: Optional[str] = None,
+                 query: Optional[str] = None,
+                 fragment: Optional[str] = None,
+                 object = None) -> None:
+        
+        self._scheme = scheme if scheme else 'gedcomx'
+        self._authority = authority
+        self._path = path
+        self._query = query
+        self._fragment = fragment
+        self._object = None
+
+        if object is not None:
+            self._object = object
+            if hasattr(object,'_uri'):
+                self._object._uri = self
+
+
+    @property
+    def _uri(self) -> str:
+        uri = ""
+        if self._scheme:
+            uri += f"{self._scheme}://"
+        if self._authority:
+            uri += f"{self._authority}/"
+        if self._path:
+            uri += f"{self._path}/"
+        if self._query:
+            uri += f"?{self._query}"
+        if self._fragment:
+            uri += f"#{self._fragment}"
+        return uri
+    
+    @property
+    def value(self):
+        return self._uri
+    
+    @property
+    def _as_dict_(self):
+        return {"Resource":self._uri}
+    
+    
+    @classmethod
+    def _from_json_(obj,text):
+        return URI(scheme='NEED TO DEAL WITH URI')

gedcomx/_Resource.py

@@ -0,0 +1,11 @@
+from typing import Any
+from .URI import URI
+
+class Resource:
+    def __init__(self, obj: Any):
+        if isinstance(obj,URI):
+            pass
+        elif hasattr(obj,'_uri'):
+            pass
+        else:
+            return None

gedcomx/__init__.py

@@ -0,0 +1,39 @@
+from .Agent import Agent
+from .Address import Address
+from .Attribution import Attribution
+from .Conclusion import Conclusion
+from .Coverage import Coverage
+from .Date import Date
+from .Document import Document
+from .Document import DocumentType
+from .EvidenceReference import EvidenceReference
+from .Event import Event
+from .Event import EventType
+from .Event import EventRole
+from .Fact import Fact
+from .Fact import FactQualifier
+from .Fact import FactType
+from .Gedcom import Gedcom
+from .GedcomX import GedcomX, Translater
+from .Gender import Gender, GenderType
+from .Group import Group, GroupRole
+from .Identifier import Identifier, IdentifierType
+from .Name import Name, NameForm, NamePart, NamePartType, NameType, NamePartQualifier
+from .Note import Note
+from .OnlineAccount import OnlineAccount
+from .Person import Person
+from .PlaceDescription import PlaceDescription
+from .PlaceReference import PlaceReference
+from .Qualifier import Qualifier
+from .Relationship import Relationship, RelationshipType
+from .Serialization import serialize_to_dict
+from .SourceCitation import SourceCitation
+from .SourceDescription import SourceDescription
+from .SourceDescription import ResourceType
+from .SourceReference import SourceReference
+from .Subject import Subject
+from .TextValue import TextValue
+from .URI import URI
+
+
+