gedcom-x 0.5__py3-none-any.whl

gedcom_x-0.5.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: gedcom-x
+Version: 0.5
+Summary: Python implimentation of gedcom-x standard
+Author-email: "David J. Cartwright" <davidcartwright@hotmail.com>
+License: MIT
+Keywords: gedcom,gedcomx,ged
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: requires-python

gedcom_x-0.5.dist-info/RECORD

@@ -0,0 +1,37 @@
+gedcomx/Address.py,sha256=gAi9vfSLdTBAsNpCNIV9mdOaB9ewoPpW-7Xrt6JYsPc,3672
+gedcomx/Agent.py,sha256=lp_--92eEo1df0nBqV2pJJafv_Zfzfz_bNj-UlJIjJk,3478
+gedcomx/Attribution.py,sha256=yVctLjdgDWp4d-uOOxHXsCyJvvGLyzkY-x2ysiYv4yc,4367
+gedcomx/Conclusion.py,sha256=hymaHcHk2JayGAGpxOlJvxzxnDjPh2q67eXI9TQk50c,5240
+gedcomx/Coverage.py,sha256=FuVsLDAhzS4HjNHKOHCjwQcvnxd4Uf_EeF3QcDEbems,912
+gedcomx/Date.py,sha256=A21KaTl44dLnMuB2hAcZ7QbqmgaQC27LoNPl4uI3i48,741
+gedcomx/Document.py,sha256=F04hRAddU5OmwAeULbXJRRAPh5CJIzeaaxFK6TI48d0,1850
+gedcomx/Event.py,sha256=qZNGEYdS3jmKI0fnw1DM5zETTw7Du07A_1tr3sc02-w,9538
+gedcomx/EvidenceReference.py,sha256=8LNyfnjLmXt4RbOHpRyw-VHyD2CCm33pPYuYqWIaxtg,333
+gedcomx/Fact.py,sha256=7UVDiimuF8LJG7ASqVdCLKed1YWqb4YhAANI0KJLwdA,23682
+gedcomx/Gedcom.py,sha256=Dn0I8SInN1K_Q_K2CAzZYX1Zer3TwGaNlw5J4rJj688,12692
+gedcomx/GedcomX.py,sha256=bWNeBPxFGaVeTIbHgyEzrefk6rwq-XzI3VOkxsrp5aw,50225
+gedcomx/Gender.py,sha256=98__1lMIdGLfMmUSh5jrqQ0SwQzN1xedgMiW9Gpabko,1720
+gedcomx/Group.py,sha256=ayp3wZEnR8vSuPwe-KfeH8MM0uQ3HJH8NGRnHDPV58M,1586
+gedcomx/Identifier.py,sha256=aFXJQNyWvfnIzUt7ALrRTtwQjSjuToCY7qLBFFVmRC8,3398
+gedcomx/Name.py,sha256=cQkWDjhuF62aoRdGUBXZy6kfvXAmUz7AxWDbnZ-bWIA,11650
+gedcomx/Note.py,sha256=PLElHAQ3XFwETL71UgGkmP4ir5s9nBo3X83jwrRBnTc,2132
+gedcomx/OnlineAccount.py,sha256=dm9HbWWf1Xekn8grDJtWChDOR-hxrIxmIRFiPRx2SQQ,276
+gedcomx/Person.py,sha256=B2zqHN8kYq4K8uRIayRxYOi6Dp7fiiv9EKd-pNDxG6U,7357
+gedcomx/PlaceDescription.py,sha256=EEBWAuxHQr1Kx4PoUOOsu26g4I5ICV1emx1mQXEU1vM,1971
+gedcomx/PlaceReference.py,sha256=N7kU8pjtmsru5tzD3cdyXkYlaRb7ncueyCqj9fihi6U,929
+gedcomx/Qualifier.py,sha256=mZ_GWT3gca8g9nWidlXIRTN5dEtf_rmnLHYl1jJkQYs,728
+gedcomx/Relationship.py,sha256=MVuIzHxw6jTFfOx-HK4VhnMxystZ_tWA3dv1cHJJQjo,4599
+gedcomx/Serialization.py,sha256=LYH3HuSwTLEmM8DQyU0MTrIUBIThGy7uG45AfzDaCrA,1277
+gedcomx/SourceCitation.py,sha256=WyeXHS2HbqxHCmVvcffr5xNTK8xxy68yaY_wX8seJuY,622
+gedcomx/SourceDescription.py,sha256=dOg7-omwHVEI2-NaRNPh8ciXKwJ1ooZKDd3iwBzkiP0,11884
+gedcomx/SourceReference.py,sha256=OpD1hQH_xA-BGw7Lt17wU9u1L98V2FBtxlNQgJrMXrc,7252
+gedcomx/Subject.py,sha256=jGDYgTDIaQrECC9DtQBS2k76ik-yr39ZVDyjhQKCem8,3116
+gedcomx/TextValue.py,sha256=znGDzzb-pNCaatwS7kxcUT1g_csswhnD5zebkLKmdV8,1098
+gedcomx/TopLevelTypeCollection.py,sha256=nvTO6GwFwEZk9jX4fVqhy75ygsshomNb20tnlExKqyY,1495
+gedcomx/URI.py,sha256=OUSCFA7oOtJ7Ya4mTJFoJawq0bZt8BDg8masb9XX-cY,2143
+gedcomx/_Resource.py,sha256=JqtbinRXpt6dLUXUtqGCZ2WmcYmGRzqXmjaw8YPpnYE,242
+gedcomx/__init__.py,sha256=brX-pkFLY5owEk1CKnArX5qXlpTu9PTu0mG_VG12ox4,1362
+gedcom_x-0.5.dist-info/METADATA,sha256=m_ewdjTzhhU2JSxpZvKT2LI_Dopam9Kbdt2X_GVPtiA,631
+gedcom_x-0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gedcom_x-0.5.dist-info/top_level.txt,sha256=smVBF4nxSU-mzCd6idtRYTbYjPICMMi8pTqewEmqF8Y,8
+gedcom_x-0.5.dist-info/RECORD,,

gedcom_x-0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gedcom_x-0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+gedcomx

gedcomx/Address.py

@@ -0,0 +1,100 @@
+from typing import Optional
+import json
+
+class Address:
+    identifier = "http://gedcomx.org/v1/Address"
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, value: Optional[str] = None,
+                 city: Optional[str] = None,
+                 country: Optional[str] = None,
+                 postalCode: Optional[str] = None,
+                 stateOrProvince: Optional[str] = None,
+                 street: Optional[str] = None,
+                 street2: Optional[str] = None,
+                 street3: Optional[str] = None,
+                 street4: Optional[str] = None,
+                 street5: Optional[str] = None,
+                 street6: Optional[str] = None):
+        
+        self._value = value #TODO impliment a parser for date strings.
+        self.city = city
+        self.country = country
+        self.postalCode = postalCode
+        self.stateOrProvince = stateOrProvince
+        self.street = street
+        self.street2 = street2
+        self.street3 = street3
+        self.street4 = street4
+        self.street5 = street5
+        self.street6 = street6
+
+    @property
+    def value(self) -> Optional[str]:
+        if self._value:
+            return self._value
+        return ', '.join(filter(None, [
+            self._street, self._street2, self._street3,
+            self._street4, self._street5, self._street6,
+            self._city, self._stateOrProvince,
+            self._postalCode, self._country
+        ]))
+    
+         
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        
+        return (
+            self.value == other.value and
+            self.city == other.city and
+            self.country == other.country and
+            self.postalCode == other.postalCode and
+            self.stateOrProvince == other.stateOrProvince and
+            self.street == other.street and
+            self.street2 == other.street2 and
+            self.street3 == other.street3 and
+            self.street4 == other.street4 and
+            self.street5 == other.street5 and
+            self.street6 == other.street6
+        )
+    
+    def __str__(self) -> str:
+        # Combine non-empty address components into a formatted string
+        parts = [
+            self._value,
+            self.street,
+            self.street2,
+            self.street3,
+            self.street4,
+            self.street5,
+            self.street6,
+            self.city,
+            self.stateOrProvince,
+            self.postalCode,
+            self.country
+        ]
+
+        # Filter out any parts that are None or empty strings
+        filtered_parts = [str(part) for part in parts if part]
+
+        # Join the remaining parts with a comma and space
+        return ', '.join(filtered_parts)
+    
+    @property
+    def __as_dict__(self):
+        return {
+            #"value": self._value if self._value else None,
+            "city": self.city if self.city else None,
+            "country": self.country if self.country else None,
+            "postalCode": self.postalCode if self.postalCode else None,
+            "stateOrProvince": self.stateOrProvince if self.stateOrProvince else None,
+            "street": self.street if self.street else None,
+            "street2": self.street2 if self.street2 else None,
+            "street3": self.street3 if self.street3 else None,
+            "street4": self.street4 if self.street4 else None,
+            "street5": self.street5 if self.street5 else None,
+            "street6": self.street6 if self.street6 else None
+        }
+
+

gedcomx/Agent.py

@@ -0,0 +1,83 @@
+import base64
+import uuid
+
+from typing import List, Optional
+
+from .Address import Address
+from .Identifier import Identifier
+from .OnlineAccount import OnlineAccount
+from .TextValue import TextValue
+from .URI import URI
+
+class Agent:
+    @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 short_uuid
+    
+    def __init__(self, id: Optional[str] = None,
+                    identifiers: Optional[List[Identifier]] = [], 
+                    names: Optional[List[TextValue]] = [], 
+                    homepage: Optional[URI] = None, 
+                    openid: Optional[URI] = None, 
+                    accounts: Optional[List[OnlineAccount]] = [],
+                    emails: Optional[List[URI]] = [], 
+                    phones: Optional[List[URI]] = [], 
+                    addresses: Optional[List[Address]] = [], 
+                    person: Optional[object] | Optional[URI] = None, # should be of Type 'Person', 'object' to avoid circular imports
+                    uri: URI = None): 
+        
+        self._id_generator = Agent.default_id_generator
+
+        self.id = id if id else self._id_generator()
+        self.identifiers = identifiers
+        self.names = names
+        self.homepage = homepage
+        self.openid = openid
+        self.accounts = accounts
+        self.emails = emails
+        self.phones = phones
+        self.addresses = addresses
+        
+        self._uri = URI(fragment="agent:"+ self.id)
+    
+    def _append_to_name(self, text_to_append: str):
+        self.names[0].value = self.names[0].value + text_to_append
+
+    def add_address(self, address_to_add: Address):
+        if address_to_add and isinstance(address_to_add, Address):
+            for current_address in self.addresses:
+                if address_to_add == current_address:
+                    return False
+            self.addresses.append(address_to_add)
+        else:
+            raise ValueError(f"address must be of type Address, not {type(address_to_add)}")
+        
+    def add_name(self, name_to_add: TextValue):
+        if isinstance(name_to_add,str): name_to_add = TextValue(value=name_to_add)
+        if name_to_add and isinstance(name_to_add,TextValue):
+            for current_name in self.names:
+                if name_to_add == current_name:
+                    return
+            self.names.append(name_to_add)
+        else:
+            raise ValueError(f'name must be of type str or TextValue, recived {type(name_to_add)}')
+    
+    @property
+    def __as_dict__(self):
+        return {
+            "id": self.id if self.id else None,
+            "identifiers": [identifier.__as_dict__() for identifier in self.identifiers],
+            "names": [name._prop_dict() for name in self.names],
+            "homepage": self.homepage if self.homepage else None,
+            "openid": self.openid if self.openid else None,
+            "accounts": self.accounts if self.accounts else None,
+            "emails": self.emails if self.emails else None,
+            "phones": self.phones if self.phones else None,
+            "addresses": [address.__as_dict__ for address in self.addresses]
+        }

gedcomx/Attribution.py

@@ -0,0 +1,116 @@
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+from .URI import URI
+
+class Attribution:
+    identifier = 'http://gedcomx.org/v1/Attribution'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,contributor: Optional[URI],
+                 modified: Optional[datetime],
+                 changeMessage: Optional[str],
+                 creator: Optional[URI],
+                 created: Optional[datetime]) -> None:
+        
+
+        from .Agent import Agent
+        self._contributor_object = None
+        self.modified = modified
+        self.changeMessage = changeMessage
+        self.creator = creator
+        self.created = created
+
+
+        if isinstance(contributor,URI):
+            # TODO DEAL WITH URI <------------------------------------------------------------------------------------------------------------------
+            self._contributor_object = contributor
+        elif isinstance(contributor,Agent):
+            self._contributor_object = contributor
+            if hasattr(contributor,'_uri'):
+                self.contributor = contributor._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(contributor)} was provided, with value: {contributor}")
+    
+    @property
+    def _as_dict_(self) -> Dict[str, Any]:
+        """
+        Serialize Attribution to a JSON-ready dict, skipping None values.
+        """
+        def _fmt_dt(dt: datetime) -> str:
+            # ISO 8601 format
+            return dt.isoformat()
+
+        data: Dict[str, Any] = {}
+        if self._contributor_object:
+            data['contributor'] = (self._contributor_object._as_dict_
+                                   if hasattr(self._contributor_object, '_as_dict_') else
+                                   None)
+        if self.created:
+            data['created'] = _fmt_dt(self.created)
+        if self.creator:
+            data['creator'] = (self.creator._prop_dict()
+                                if hasattr(self.creator, '_prop_dict') else
+                                self.creator._prop_dict())
+        if self.modified:
+            data['modified'] = _fmt_dt(self.modified)
+        if self.changeMessage is not None:
+            data['changeMessage'] = self.changeMessage    
+        return data
+
+    @classmethod
+    def _from_json_(cls, data: Dict[str, Any]) -> 'Attribution':
+        """
+        Construct Attribution from a dict (as parsed from JSON).
+        Handles 'created' and 'modified' as ISO strings or epoch ms ints.
+        """
+        # contributor
+        contrib = None
+        if 'contributor' in data:
+            raw = data['contributor']
+            if isinstance(raw, dict):
+                contrib = URI._from_json_(raw)
+            elif isinstance(raw, str):
+                contrib = URI(uri=raw)
+
+        # creator
+        creat = None
+        if 'creator' in data:
+            raw = data['creator']
+            if isinstance(raw, dict):
+                creat = URI._from_json_(raw)
+            elif isinstance(raw, str):
+                creat = URI(uri=raw)
+
+        # parse created date
+        raw_created = data.get('created')
+        if isinstance(raw_created, (int, float)):
+            created_dt = datetime.fromtimestamp(raw_created / 1000.0)
+        elif isinstance(raw_created, str):
+            created_dt = datetime.fromisoformat(raw_created)
+        else:
+            created_dt = None
+
+        # parse modified date
+        raw_modified = data.get('modified')
+        if isinstance(raw_modified, (int, float)):
+            modified_dt = datetime.fromtimestamp(raw_modified / 1000.0)
+        elif isinstance(raw_modified, str):
+            modified_dt = datetime.fromisoformat(raw_modified)
+        else:
+            modified_dt = None
+
+        change_msg = data.get('changeMessage')
+
+        return cls(
+            contributor=contrib,
+            created=created_dt,
+            creator=creat,
+            modified=modified_dt,
+            changeMessage=change_msg
+        )

gedcomx/Conclusion.py

@@ -0,0 +1,137 @@
+import base64
+import uuid
+import warnings
+
+from typing import List, Optional
+
+from .Attribution import Attribution
+from .Note import Note
+from .Qualifier import Qualifier
+from .SourceReference import SourceReference
+from .URI import URI
+
+class ConfidenceLevel(Qualifier):
+    High = "http://gedcomx.org/High"
+    Medium = "http://gedcomx.org/Medium"
+    Low = "http://gedcomx.org/Low"
+    
+    @property
+    def description(self):
+        descriptions = {
+            ConfidenceLevel.High: "The contributor has a high degree of confidence that the assertion is true.",
+            ConfidenceLevel.Medium: "The contributor has a medium degree of confidence that the assertion is true.",
+            ConfidenceLevel.Low: "The contributor has a low degree of confidence that the assertion is true."
+        }
+        return descriptions.get(self, "No description available.")
+    
+class Conclusion:
+    identifier = 'http://gedcomx.org/v1/Conclusion'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    @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 short_uuid
+    
+    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,
+                 uri: Optional[URI] = None,
+                 max_note_count: int = 20) -> None:
+        
+        self._id_generator = Conclusion.default_id_generator
+
+        self.id = id if id else self._id_generator()
+        self.lang = lang
+        self.sources = sources
+        self.analysis = analysis
+        self.notes = notes
+        self.confidence = confidence
+        self.attribution = attribution
+        self.max_note_count = max_note_count
+        self._uri = uri if uri else URI(fragment=id)
+    
+    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: SourceReference):
+        if source_to_add and isinstance(source_to_add,SourceReference):
+            for current_source in self.sources:
+                if source_to_add == current_source:
+                    return
+            self.sources.append(source_to_add)
+        else:
+            raise ValueError()
+    
+    '''
+    def _as_dict_(self):
+        return {
+            'id':self.id,
+            'lang':self.lang,
+            'sources': [source._prop_dict() for source in self.sources] if self.sources else None,
+            'analysis': self.analysis._uri if self.analysis else None,
+            'notes':"Add notes here",
+            'confidence':self.confidence
+        }
+    '''
+    
+    @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
+        conclusion_fields = {
+            'id':self.id,
+            'lang':self.lang,
+            'sources': [source for source in self.sources] if self.sources else None,
+            'analysis': self.analysis._uri if self.analysis else None,
+            'notes': [note for note in self.notes] if self.notes else None,
+            'confidence':self.confidence
+        }
+
+        # Serialize and exclude None values
+        for key, value in conclusion_fields.items():
+            if value is not None:
+                                conclusion_fields[key] = _serialize(value)
+        return conclusion_fields
+    
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        
+        return (
+            self.id == other.id and
+            self.lang == other.lang and
+            self.sources == other.sources and
+            self.analysis == other.analysis and
+            self.notes == other.notes and
+            self.confidence == other.confidence and
+            self.attribution == other.attribution
+        )

gedcomx/Coverage.py

@@ -0,0 +1,26 @@
+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...
+
+    @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/Date.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+
+class DateFormat:
+    def __init__(self) -> None:
+        pass
+        
+
+class Date:
+    identifier = 'http://gedcomx.org/v1/Date'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self, original: Optional[str],formal: Optional[str | DateFormat] = None) -> None:
+        self.orginal = original
+        self.formal = formal
+    
+    def _prop_dict(self):
+        return {'original': self.orginal,
+                'formal': self.formal}
+
+# Date
+Date._from_json_ = classmethod(lambda cls, data: Date(
+    original=data.get('original'),
+    formal=data.get('formal')
+))
+
+Date._to_dict_ = lambda self: {
+    'original': self.orginal,
+    'formal': self.formal}    

gedcomx/Document.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import 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
+
+class DocumentType(Enum):
+    Abstract = "http://gedcomx.org/Abstract"
+    Transcription = "http://gedcomx.org/Transcription"
+    Translation = "http://gedcomx.org/Translation"
+    Analysis = "http://gedcomx.org/Analysis"
+    
+    @property
+    def description(self):
+        descriptions = {
+            DocumentType.Abstract: "The document is an abstract of a record or document.",
+            DocumentType.Transcription: "The document is a transcription of a record or document.",
+            DocumentType.Translation: "The document is a translation of a record or document.",
+            DocumentType.Analysis: "The document is an analysis done by a researcher; a genealogical proof statement is an example of one kind of analysis document."
+        }
+        return descriptions.get(self, "No description available.")
+
+class TextType(Enum):
+    plain = 'plain'
+    xhtml = 'xhtml'
+
+class Document(Conclusion):
+    identifier = 'http://gedcomx.org/v1/Document'
+    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,
+                 type: Optional[DocumentType],
+                 extracted: Optional[bool], # Default to False
+                 textType: Optional[TextType],
+                 text: str,
+                 ) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)