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

gedcomx/SourceCitation.py

@@ -1,25 +0,0 @@
-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)
-    
-    @property
-    def _as_dict_(self):
-        return {'lang':self.lang,
-                'value': self.value}

gedcomx/SourceDescription.py

@@ -1,314 +0,0 @@
-import warnings
-
-from enum import Enum
-from typing import List, Optional, Dict, Any
-
-from typing import Optional, TYPE_CHECKING
-if TYPE_CHECKING:
-    from .Document import Document
-
-"""
-======================================================================
- Project: Gedcom-X
- File:    SourceDescription.py
- Author:  David J. Cartwright
- Purpose: 
-
- Created: 2025-07-25
- Updated:
-   - 2025-08-31: _as_dict_ refactored to ignore empty fields, changed id creation to make_uid()
- 
-   
-======================================================================
-"""
-
-"""
-======================================================================
-GEDCOM Module Types
-======================================================================
-"""
-from .Agent import Agent
-from .Attribution import Attribution
-from .Coverage import Coverage
-from .Date import Date
-from .Identifier import Identifier, IdentifierList, make_uid
-from .Note import Note
-from .Resource import Resource
-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"
-    Person = "http://gedcomx.org/Person"    
-    
-    @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:
-    """Description of a genealogical information source.
-
-    See: http://gedcomx.org/v1/SourceDescription
-
-    Args:
-        id (str | None): Unique identifier for this `SourceDescription`.
-        resourceType (ResourceType | None): Type/category of the resource being
-            described (e.g., digital artifact, physical artifact).
-        citations (list[SourceCitation] | None): Citations that reference or
-            justify this source description.
-        mediaType (str | None): IANA media (MIME) type of the resource
-            (e.g., ``"application/pdf"``).
-        about (URI | None): Canonical URI that the description is about.
-        mediator (Resource | None): The mediator resource (if any) involved in
-            providing access to the source.
-        publisher (Resource | Agent | None): Publisher of the resource.
-        authors (list[Resource] | None): Authors/creators of the resource.
-        sources (list[SourceReference] | None): Other sources this description
-            derives from or references.
-        analysis (Resource | None): Analysis document associated with the
-            resource (often a `Document`; kept generic to avoid circular imports).
-        componentOf (SourceReference | None): Reference to a parent/containing
-            source (this is a component/child of that source).
-        titles (list[TextValue] | None): One or more titles for the resource.
-        notes (list[Note] | None): Human-authored notes about the resource.
-        attribution (Attribution | None): Attribution metadata for who supplied
-            or curated this description.
-        rights (list[Resource] | None): Rights statements or licenses.
-        coverage (list[Coverage] | None): Spatial/temporal coverage of the
-            source’s content.
-        descriptions (list[TextValue] | None): Short textual summaries or
-            descriptions.
-        identifiers (IdentifierList | None): Alternative identifiers for the
-            resource (DOI, ARK, call numbers, etc.).
-        created (Date | None): Creation date of the resource.
-        modified (Date | None): Last modified date of the resource.
-        published (Date | None): Publication/release date of the resource.
-        repository (Agent | None): Repository or agency that holds the resource.
-        max_note_count (int): Maximum number of notes to retain/emit. Defaults to 20.
-
-    Raises:
-        ValueError: If `id` is not a valid UUID.
-
-    Attributes:
-        identifier (str): Gedcom-X specification identifier for this type.
-    """
-
-    identifier = "http://gedcomx.org/v1/SourceDescription"
-    version = 'http://gedcomx.org/conceptual-model/v1'
-    
-    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[Agent|Resource] = None,
-                 publisher: Optional[Agent|Resource] = None,
-                 authors: Optional[List[Resource]] = None,
-                 sources: Optional[List[SourceReference]] = None, # SourceReference
-                 analysis: Optional["Document|Resource"] = None,  #TODO add type checker so its a document
-                 componentOf: Optional[SourceReference] = None, # SourceReference
-                 titles: Optional[List[TextValue]] = None,
-                 notes: Optional[List[Note]] = None,
-                 attribution: Optional[Attribution] = None,
-                 rights: Optional[List[Resource]] = [],
-                 coverage: Optional[List[Coverage]] = None, # Coverage
-                 descriptions: Optional[List[TextValue]] = None,
-                 identifiers: Optional[IdentifierList] = None,
-                 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 make_uid()
-        self.resourceType = resourceType
-        self.citations = citations or []
-        self.mediaType = mediaType
-        self.about = about
-        self.mediator = mediator
-        self._publisher = publisher 
-        self.authors = authors or []
-        self.sources = 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 IdentifierList()
-        self.created = created
-        self.modified = modified
-        self.published = published
-        self.repository = repository
-        self.max_note_count = max_note_count
-
-        self.uri = URI(fragment=id) if id else None #TODO Should i take care of this in the collections?
-    
-    @property
-    def publisher(self) -> Resource | Agent | None:
-        return self._publisher
-    
-
-    @publisher.setter
-    def publisher(self, value: Resource | Agent):
-        if value is None:
-            self._publisher = None
-        elif isinstance(value,Resource):
-            self._publisher = value
-        elif isinstance(value,Agent):
-            self._publisher = value
-        else:
-            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")
-    
-    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):
-            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: 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)}")
-            
-    @property
-    def _as_dict_(self) -> Dict[str, Any]:
-        from .Serialization import Serialization
-        type_as_dict = {}
-
-        if self.id:
-            type_as_dict['id'] = self.id
-        if self.about:
-            type_as_dict['about'] = self.about._as_dict_
-        if self.resourceType:
-            type_as_dict['resourceType'] = getattr(self.resourceType, 'value', self.resourceType)
-        if self.citations:
-            type_as_dict['citations'] = [c._as_dict_ for c in self.citations if c]
-        if self.mediaType:
-            type_as_dict['mediaType'] = self.mediaType
-        if self.mediator:
-            type_as_dict['mediator'] = self.mediator._as_dict_
-        if self.publisher:
-            type_as_dict['publisher'] = self.publisher._as_dict_ #TODO Resource this
-        if self.authors:
-            type_as_dict['authors'] = [a._as_dict_ for a in self.authors if a]
-        if self.sources:
-            type_as_dict['sources'] = [s._as_dict_ for s in self.sources if s]
-        if self.analysis:
-            type_as_dict['analysis'] = self.analysis._as_dict_
-        if self.componentOf:
-            type_as_dict['componentOf'] = self.componentOf._as_dict_ 
-        if self.titles:
-            type_as_dict['titles'] = [t._as_dict_ for t in self.titles if t]
-        if self.notes:
-            type_as_dict['notes'] = [n._as_dict_ for n in self.notes if n]
-        if self.attribution:
-            type_as_dict['attribution'] = self.attribution._as_dict_
-        if self.rights:
-            type_as_dict['rights'] = [r._as_dict_ for r in self.rights if r]
-        if self.coverage:
-            type_as_dict['coverage'] = [c._as_dict_ for c in self.coverage if c]
-        if self.descriptions:
-            type_as_dict['descriptions'] = [d for d in self.descriptions if d]
-        if self.identifiers:
-            type_as_dict['identifiers'] = self.identifiers._as_dict_
-        if self.created is not None:
-            type_as_dict['created'] = self.created
-        if self.modified is not None:
-            type_as_dict['modified'] = self.modified
-        if self.published is not None:
-            type_as_dict['published'] = self.published
-        if self.repository:
-            type_as_dict['repository'] = self.repository._as_dict_ #TODO Resource this
-        if self.uri and self.uri.value:
-            type_as_dict['uri'] = self.uri.value
-
-        
-        return Serialization.serialize_dict(type_as_dict)
-         
-            
-    @classmethod
-    def _from_json_(cls, data: Dict[str, Any]) -> 'SourceDescription':
-        # 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     = Resource._from_json_(data['mediator']) if data.get('mediator') else None
-        publisher    = Resource._from_json_(data['publisher']) if data.get('publisher') else None
-        authors      = [Resource._from_json_(a) for a in data.get('authors', [])] if data.get('authors') else None
-        sources      = [SourceReference._from_json_(s) for s in data.get('sources', [])]
-        analysis     = Resource._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  = IdentifierList._from_json_(data.get('identifiers', []))
-        
-        created      = Date._from_json_(data['created']) if data.get('created') else None
-        modified     = data.get('modified',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
-        )
-
-    

gedcomx/Subject.py

@@ -1,59 +0,0 @@
-import warnings
-from typing import List, Optional
-
-from .Attribution import Attribution
-from .Conclusion import Conclusion, ConfidenceLevel
-from .EvidenceReference import EvidenceReference
-from .Identifier import Identifier, IdentifierList
-from .Note import Note
-
-from .SourceReference import SourceReference
-from .Resource import Resource
-from .Extensions.rs10.rsLink import _rsLinkList
-
-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[Resource] = 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[IdentifierList] = None,
-                 uri: Optional[Resource] = None,
-                 links: Optional[_rsLinkList] = None) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution,links=links)
-        self.extracted = extracted
-        self.evidence = evidence
-        self.media = media
-        self.identifiers = identifiers if identifiers else IdentifierList()
-        self.uri = uri
-        
-    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):
-        from .Serialization import Serialization
-
-        type_as_dict = super()._as_dict_  # Start with base class fields
-        # Only add Relationship-specific fields
-        type_as_dict.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": self.identifiers._as_dict_ if self.identifiers else None
-                           
-        })
-        return Serialization.serialize_dict(type_as_dict)

gedcomx/TextValue.py

@@ -1,35 +0,0 @@
-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
-    
-    @property
-    def _as_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/URI.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass, field
-from typing import Mapping, Optional, Union, Iterable, Tuple
-from urllib.parse import urlsplit, urlunsplit, urlencode, parse_qsl, SplitResult
-
-_DEFAULT_SCHEME = "gedcomx"
-
-@dataclass(frozen=False, slots=True)
-class URI:
-    scheme: str = field(default=_DEFAULT_SCHEME)
-    authority: str = field(default="")
-    path: str = field(default="")
-    query: str = field(default="")
-    fragment: str = field(default="")
-
-    # ---------- constructors ----------
-    @classmethod
-    def from_url(cls, url: str, *, default_scheme: str = _DEFAULT_SCHEME) -> "URI":
-        s = urlsplit(url)
-        scheme = s.scheme or default_scheme
-        return cls(scheme=scheme, authority=s.netloc, path=s.path, query=s.query, fragment=s.fragment)
-
-    @classmethod
-    def parse(cls, value: str) -> "URI":
-        return cls.from_url(value)
-
-    @classmethod
-    def from_parts(
-        cls,
-        *,
-        scheme: Optional[str] = None,
-        authority: str = "",
-        path: str = "",
-        query: Union[str, Mapping[str, str], Iterable[Tuple[str, str]]] = "",
-        fragment: str = ""
-    ) -> "URI":
-        q = query if isinstance(query, str) else urlencode(query, doseq=True)
-        return cls(scheme=scheme or _DEFAULT_SCHEME, authority=authority, path=path, query=q, fragment=fragment)
-
-    # ---------- views ----------
-    @property
-    def value(self) -> str:
-        return str(self)
-
-    def split(self) -> SplitResult:
-        return SplitResult(self.scheme, self.authority, self.path, self.query, self.fragment)
-
-    def __str__(self) -> str:
-        return urlunsplit(self.split())
-
-    @property
-    def _as_dict_(self) -> str:
-        # Keeps a simple, explicit structure
-        return urlunsplit(self.split())
-        return {
-            "scheme": self.scheme,
-            "authority": self.authority,
-            "path": self.path,
-            "query": self.query,
-            "fragment": self.fragment,
-            "value": str(self),
-        }
-
-    # Accepts {'resource': '...'} or a plain string, mirroring your original
-    @classmethod
-    def from_jsonish(cls, data: Union[str, Mapping[str, str]]) -> "URI":
-        if isinstance(data, str):
-            return cls.from_url(data)
-        if isinstance(data, Mapping):
-            raw = data.get("resource") or data.get("value") or ""
-            if raw:
-                return cls.from_url(raw)
-        raise ValueError(f"Cannot build URI from: {data!r}")
-
-    # ---------- functional updaters ----------
-    def with_scheme(self, scheme: str) -> "URI": return self.replace(scheme=scheme)
-    def with_authority(self, authority: str) -> "URI": return self.replace(authority=authority)
-    def with_path(self, path: str, *, join: bool = False) -> "URI":
-        new_path = (self.path.rstrip("/") + "/" + path.lstrip("/")) if join else path
-        return self.replace(path=new_path)
-    def with_fragment(self, fragment: str | None) -> "URI":
-        return self.replace(fragment=(fragment or ""))
-    def without_fragment(self) -> "URI": return self.replace(fragment="")
-    def with_query(self, query: Union[str, Mapping[str, str], Iterable[Tuple[str, str]]]) -> "URI":
-        q = query if isinstance(query, str) else urlencode(query, doseq=True)
-        return self.replace(query=q)
-    def add_query_params(self, params: Mapping[str, Union[str, Iterable[str]]]) -> "URI":
-        existing = parse_qsl(self.query, keep_blank_values=True)
-        for k, v in params.items():
-            if isinstance(v, str):
-                existing.append((k, v))
-            else:
-                for vv in v:
-                    existing.append((k, vv))
-        return self.replace(query=urlencode(existing, doseq=True))
-
-    # ---------- helpers ----------
-    def replace(self, **kwargs) -> "URI":
-        return URI(
-            scheme=kwargs.get("scheme", self.scheme or _DEFAULT_SCHEME),
-            authority=kwargs.get("authority", self.authority),
-            path=kwargs.get("path", self.path),
-            query=kwargs.get("query", self.query),
-            fragment=kwargs.get("fragment", self.fragment),
-        )