gedcom-x 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

gedcomx/{URI.py → uri.py}

@@ -1,11 +1,25 @@
 from __future__ import annotations
 from dataclasses import dataclass, field
-from typing import Mapping, Optional, Union, Iterable, Tuple
+from typing import Mapping, Sequence, Tuple, Union, Iterable
 from urllib.parse import urlsplit, urlunsplit, urlencode, parse_qsl, SplitResult
 
 _DEFAULT_SCHEME = "gedcomx"
 
-@dataclass(frozen=False, slots=True)
+# ---------- typing helpers for urlencode (Option A) ----------
+QuerySeq = Sequence[Tuple[str, str]]
+QueryMap = Mapping[str, str]
+QueryLike = Union[str, QueryMap, QuerySeq]
+
+def _encode_query(q: QueryLike) -> str:
+    """Return a properly encoded query string."""
+    if isinstance(q, str):
+        return q
+    if isinstance(q, Mapping):
+        return urlencode(q, doseq=True)          # mapping is fine
+    return urlencode(list(q), doseq=True)        # coerce iterable to a sequence
+
+
+@dataclass(slots=True)
 class URI:
     scheme: str = field(default=_DEFAULT_SCHEME)
     authority: str = field(default="")
@@ -15,29 +29,33 @@ class URI:
 
     # ---------- constructors ----------
     @classmethod
-    def from_url(cls, url: str, *, default_scheme: str = _DEFAULT_SCHEME) -> "URI":
+    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":
+    def parse(cls, value: str) -> URI:
         return cls.from_url(value)
 
     @classmethod
     def from_parts(
         cls,
         *,
-        scheme: Optional[str] = None,
+        scheme: str | None = 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)
+        query: QueryLike = "",
+        fragment: str = "",
+    ) -> URI:
+        q = _encode_query(query)
         return cls(scheme=scheme or _DEFAULT_SCHEME, authority=authority, path=path, query=q, fragment=fragment)
 
     # ---------- views ----------
+    @property
+    def uri(self) -> str:
+        return str(self)
+    
     @property
     def value(self) -> str:
         return str(self)
@@ -49,9 +67,7 @@ class URI:
         return urlunsplit(self.split())
 
     @property
-    def _as_dict_(self) -> dict:
-        # Keeps a simple, explicit structure
-        return urlunsplit(self.split())
+    def _as_dict_(self) -> dict[str, object]:
         return {
             "scheme": self.scheme,
             "authority": self.authority,
@@ -61,30 +77,29 @@ class URI:
             "value": str(self),
         }
 
-    # Accepts {'resource': '...'} or a plain string, mirroring your original
+    # Accepts {'resource': '...'} or a plain string
     @classmethod
-    def from_jsonish(cls, data: Union[str, Mapping[str, str]]) -> "URI":
+    def from_jsonish(cls, data: str | Mapping[str, object]) -> 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:
+            if isinstance(raw, str) and 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":
+    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":
+    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":
+    def without_fragment(self) -> URI: return self.replace(fragment="")
+    def with_query(self, query: QueryLike) -> URI:
+        return self.replace(query=_encode_query(query))
+    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):
@@ -95,8 +110,9 @@ class URI:
         return self.replace(query=urlencode(existing, doseq=True))
 
     # ---------- helpers ----------
-    def replace(self, **kwargs) -> "URI":
-        return URI(
+    def replace(self, **kwargs) -> URI:
+        cls = type(self)
+        return cls(
             scheme=kwargs.get("scheme", self.scheme or _DEFAULT_SCHEME),
             authority=kwargs.get("authority", self.authority),
             path=kwargs.get("path", self.path),

gedcom_x-0.5.6.dist-info/RECORD

@@ -1,45 +0,0 @@
-gedcomx/Address.py,sha256=FDBic6oQB30eKMWM7-6_YVPHaJdPhziU5LybwE5TY5Q,4855
-gedcomx/Agent.py,sha256=C-tzfqcjuU22iJ2LjoatKdCbI_i0xskpmZsuj58K6WY,8555
-gedcomx/Attribution.py,sha256=2bcl2UNsMPn10kDrA080qFRzxK-KYqZBgmPGNBZ2M4Y,2608
-gedcomx/Conclusion.py,sha256=t8n8FuWwzinFTPHp9D2Umu93-4A12I9L5fCx510mfqA,8414
-gedcomx/Coverage.py,sha256=BVlB3kWDoOP2j86j67hNJLC4LqoLwqs3N93z0ZbXYTw,1227
-gedcomx/Date.py,sha256=cv2UeyOcTHuH2CVHq9EjTnj3FR-r4_OVuPiuc8sbOPc,2130
-gedcomx/Document.py,sha256=32nWfDNVWkPK2_I0-hhcNQkrjH3ssdbtw-II3QMMelw,2957
-gedcomx/Event.py,sha256=BHhmO2UlxbkSzB5htdMRf2h-WNuJQsWfrSC8tNGQ6Mg,10375
-gedcomx/EvidenceReference.py,sha256=WXZpmcKzwb3lYQmGVf-TY2IsbNG3fIInPY1khRjtOSg,348
-gedcomx/Exceptions.py,sha256=0OdPM3euhBMgX8o61ZwPuKeN8zPuSuuDcSBFflVGFqk,587
-gedcomx/ExtensibleEnum.py,sha256=DftCZLMBNul3C9hwh-rf0GE3SVdvylvyd5mt7bX_l6o,6535
-gedcomx/Fact.py,sha256=-Zz321xeFd93riaX4C4i7gIPwpqdArAYZDlWRoXA1Uk,24444
-gedcomx/Gedcom.py,sha256=l_BuLBynQacDtpLjhs2Afrabfiqt2Opoo_5_7myI7Z4,1709
-gedcomx/Gedcom5x.py,sha256=ZaMqvmDTn684m4uSDRy3uxgKk442K5WZjDy_0s2ga-8,22459
-gedcomx/GedcomX.py,sha256=mFviKVvk8dSn4tHPd1hkHBxoTOMNKlBv7gH3Q1n87IU,63666
-gedcomx/Gender.py,sha256=AV125vECC5JSgvNJRmotjDEt-A3cFzth6pcSLFwJBEE,2328
-gedcomx/Group.py,sha256=VNI_cI_-YnJ9cHzwMmHD8qwDNMe89kEocPuQ67rwStA,1606
-gedcomx/Identifier.py,sha256=pJB8DlMF1k5DNR0Lha6rGTTiOtwe0joVLRLQCuoXtIw,8507
-gedcomx/Logging.py,sha256=vBDOjawVXc4tCge1laYjy6_2Ves-fnGzG0m6NnLZejE,624
-gedcomx/LoggingHub.py,sha256=lOeMP_0hFPydVNuMcUC31FMBRHtRMP02pBMM8TuhsNg,7143
-gedcomx/Mutations.py,sha256=idhQsnikCTovmNEGAhDsOe97V0L9AnFTRaufzUPm64w,6298
-gedcomx/Name.py,sha256=en_VkGjpZPP_Dbl9HSq2h2JCtLS2NMzmLvis5RdBPeM,12913
-gedcomx/Note.py,sha256=cvV4-fCZ0oh2zXfzD-YYoIM_WTox-fk2_bfl3i4CoNc,2251
-gedcomx/OnlineAccount.py,sha256=P24o98IXo_8XQoICYZPgALjdzS0q8t2l4DU3Od9KxyI,291
-gedcomx/Person.py,sha256=LyGPCZh6rZU_dE3GCJE92x1lLk41c_Edr_Po9smhPLc,7321
-gedcomx/PlaceDescription.py,sha256=TRHIkDiErHa_mlx_x8gYCF6UnQ-XgT08uSmYmFNa4u0,3255
-gedcomx/PlaceReference.py,sha256=3NyEYq0FaMI8m3l4H6-Ov-n9NUq_m751iYVxofqtv30,870
-gedcomx/Qualifier.py,sha256=mZ_GWT3gca8g9nWidlXIRTN5dEtf_rmnLHYl1jJkQYs,728
-gedcomx/Relationship.py,sha256=oyT501vR5jvWxqEYy3KvW9egD4CPL5JaAYWJmlNy9Ig,3599
-gedcomx/Resource.py,sha256=bZ2dV-OdpvmDRCppyfHJXiarIKL7-OcofwvYRnpOJW0,2324
-gedcomx/Serialization.py,sha256=ubtmrvi-nKmVUCK1XGwuLijrPMggNJe--kkCIC-87Ds,18580
-gedcomx/SourceCitation.py,sha256=aW-lEb7bT9QU49GiBjJppFMBvtisR6fhVVuXjr5y4vQ,742
-gedcomx/SourceDescription.py,sha256=zOkXo-fy-uCl_EGU8B-c6pzhlMk3nYNHn13ln1AkYk0,11914
-gedcomx/SourceReference.py,sha256=swVzZ5A0jt5yFYJNJvMnQZtb7d-2YEAQPxp2a4lEY1k,5071
-gedcomx/Subject.py,sha256=znee3SxYKk99JLP6KmZHkXs5hIOGu_jeLwxagENNfXs,3298
-gedcomx/TextValue.py,sha256=6B0wMxL0nigFNzhXZDhbTONvFGbnM2t2NcDZiZuu4Zw,1112
-gedcomx/TopLevelTypeCollection.py,sha256=nvTO6GwFwEZk9jX4fVqhy75ygsshomNb20tnlExKqyY,1495
-gedcomx/Translation.py,sha256=NWa1NtTOC_VgQ-EGwWG06zUpddRxdKFSLPP6066JFaA,12485
-gedcomx/URI.py,sha256=S2pFsu_VyKgOsRdHIj8pjnh6_tdA3OjAYiIugoEd70k,4271
-gedcomx/Zip.py,sha256=lBxcv-Vip45884EHj56wZJJ5I36Q38UuHUidDxQBoS8,14
-gedcomx/__init__.py,sha256=O8LkNk9b8BHIN3mf0RowfR9M2HdKYhF8Fgi3qxW2RSs,1660
-gedcom_x-0.5.6.dist-info/METADATA,sha256=rNO-ZyEC3th_8iML9XtfJOQcnPJI1uksyWz2MB9DAV8,4332
-gedcom_x-0.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gedcom_x-0.5.6.dist-info/top_level.txt,sha256=smVBF4nxSU-mzCd6idtRYTbYjPICMMi8pTqewEmqF8Y,8
-gedcom_x-0.5.6.dist-info/RECORD,,

gedcomx/Coverage.py

@@ -1,36 +0,0 @@
-from typing import Optional
-
-from .Date import Date
-from .PlaceReference import PlaceReference
-from .Serialization import Serialization
-
-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):
-        type_as_dict = {
-            'spatial': self.spatial if self.spatial else None,
-            'temporal': self. temporal if self.temporal else None
-        }
-
-        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/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/Name.py

@@ -1,276 +0,0 @@
-from enum import Enum
-from typing import List,Optional
-from typing_extensions import Self
-
-from .Attribution import Attribution
-from .Conclusion import Conclusion, ConfidenceLevel
-from .Date import Date
-from .Note import Note
-from .Serialization import Serialization
-from .SourceReference import SourceReference
-from .Resource import Resource
-
-
-class NameType(Enum):
-    BirthName = "http://gedcomx.org/BirthName"
-    MarriedName = "http://gedcomx.org/MarriedName"
-    AlsoKnownAs = "http://gedcomx.org/AlsoKnownAs"
-    Nickname = "http://gedcomx.org/Nickname"
-    AdoptiveName = "http://gedcomx.org/AdoptiveName"
-    FormalName = "http://gedcomx.org/FormalName"
-    ReligiousName = "http://gedcomx.org/ReligiousName"
-    
-    @property
-    def description(self):
-        descriptions = {
-            NameType.BirthName: "Name given at birth.",
-            NameType.MarriedName: "Name accepted at marriage.",
-            NameType.AlsoKnownAs: "\"Also known as\" name.",
-            NameType.Nickname: "Nickname.",
-            NameType.AdoptiveName: "Name given at adoption.",
-            NameType.FormalName: "A formal name, usually given to distinguish it from a name more commonly used.",
-            NameType.ReligiousName: "A name given at a religious rite or ceremony."
-        }
-        return descriptions.get(self, "No description available.")
-
-class NamePartQualifier(Enum):
-    Title = "http://gedcomx.org/Title"
-    Primary = "http://gedcomx.org/Primary"
-    Secondary = "http://gedcomx.org/Secondary"
-    Middle = "http://gedcomx.org/Middle"
-    Familiar = "http://gedcomx.org/Familiar"
-    Religious = "http://gedcomx.org/Religious"
-    Family = "http://gedcomx.org/Family"
-    Maiden = "http://gedcomx.org/Maiden"
-    Patronymic = "http://gedcomx.org/Patronymic"
-    Matronymic = "http://gedcomx.org/Matronymic"
-    Geographic = "http://gedcomx.org/Geographic"
-    Occupational = "http://gedcomx.org/Occupational"
-    Characteristic = "http://gedcomx.org/Characteristic"
-    Postnom = "http://gedcomx.org/Postnom"
-    Particle = "http://gedcomx.org/Particle"
-    RootName = "http://gedcomx.org/RootName"
-    
-    @property
-    def description(self):
-        descriptions = {
-            NamePartQualifier.Title: "A designation for honorifics (e.g., Dr., Rev., His Majesty, Haji), ranks (e.g., Colonel, General), positions (e.g., Count, Chief), or other titles (e.g., PhD, MD). Name part qualifiers of type Title SHOULD NOT provide a value.",
-            NamePartQualifier.Primary: "A designation for the most prominent name among names of that type (e.g., the primary given name). Name part qualifiers of type Primary SHOULD NOT provide a value.",
-            NamePartQualifier.Secondary: "A designation for a name that is not primary in its importance among names of that type. Name part qualifiers of type Secondary SHOULD NOT provide a value.",
-            NamePartQualifier.Middle: "Useful for cultures designating a middle name distinct from a given name and surname. Name part qualifiers of type Middle SHOULD NOT provide a value.",
-            NamePartQualifier.Familiar: "A designation for one's familiar name. Name part qualifiers of type Familiar SHOULD NOT provide a value.",
-            NamePartQualifier.Religious: "A name given for religious purposes. Name part qualifiers of type Religious SHOULD NOT provide a value.",
-            NamePartQualifier.Family: "A name that associates a person with a group, such as a clan, tribe, or patriarchal hierarchy. Name part qualifiers of type Family SHOULD NOT provide a value.",
-            NamePartQualifier.Maiden: "Original surname retained by women after adopting a new surname upon marriage. Name part qualifiers of type Maiden SHOULD NOT provide a value.",
-            NamePartQualifier.Patronymic: "A name derived from a father or paternal ancestor. Name part qualifiers of type Patronymic SHOULD NOT provide a value.",
-            NamePartQualifier.Matronymic: "A name derived from a mother or maternal ancestor. Name part qualifiers of type Matronymic SHOULD NOT provide a value.",
-            NamePartQualifier.Geographic: "A name derived from associated geography. Name part qualifiers of type Geographic SHOULD NOT provide a value.",
-            NamePartQualifier.Occupational: "A name derived from one's occupation. Name part qualifiers of type Occupational SHOULD NOT provide a value.",
-            NamePartQualifier.Characteristic: "A name derived from a characteristic. Name part qualifiers of type Characteristic SHOULD NOT provide a value.",
-            NamePartQualifier.Postnom: "A name mandated by law for populations in specific regions. Name part qualifiers of type Postnom SHOULD NOT provide a value.",
-            NamePartQualifier.Particle: "A grammatical designation for articles, prepositions, conjunctions, and other words used as name parts. Name part qualifiers of type Particle SHOULD NOT provide a value.",
-            NamePartQualifier.RootName: "The 'root' of a name part, as distinguished from prefixes or suffixes (e.g., the root of 'Wilkówna' is 'Wilk'). A RootName qualifier MUST provide a value property."
-        }
-        return descriptions.get(self, "No description available.")
-
-class NamePartType(Enum):
-    Prefix = "http://gedcomx.org/Prefix"
-    Suffix = "http://gedcomx.org/Suffix"
-    Given = "http://gedcomx.org/Given"
-    Surname = "http://gedcomx.org/Surname"
-    
-    @property
-    def description(self):
-        descriptions = {
-            NamePartType.Prefix: "A name prefix.",
-            NamePartType.Suffix: "A name suffix.",
-            NamePartType.Given: "A given name.",
-            NamePartType.Surname: "A surname."
-        }
-        return descriptions.get(self, "No description available.")
-    
-class NamePart:
-    identifier = 'http://gedcomx.org/v1/NamePart'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self,
-                 type: Optional[NamePartType] = None,
-                 value: Optional[str] = None,
-                 qualifiers: Optional[List[NamePartQualifier]] = []) -> None:
-        self.type = type
-        self.value = value
-        self.qualifiers = qualifiers
-    
-    def _as_dict_(self):
-        return Serialization.serialize_dict(
-            {'type': self.type.value if self.type else None,
-             'value': self.value if self.value else None,
-             'qualifiers': [qualifier.value for qualifier in self.qualifiers] if self.qualifiers else None})
-
-    def __eq__(self, other):
-        if not isinstance(other, NamePart):
-            return NotImplemented
-        return (self.type == other.type and
-                self.value == other.value and
-                self.qualifiers == other.qualifiers)    
-
-class NameForm:
-    identifier = 'http://gedcomx.org/v1/NameForm'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self, lang: Optional[str] = 'en', fullText: Optional[str] = None,parts: Optional[List[NamePart]] = []) -> None:
-        self.lang = lang
-        self.fullText = fullText
-        self.parts = parts
-    
-    @property
-    def _as_dict_(self):
-        return Serialization.serialize_dict(
-            {'lang': self.lang,
-             'fullText': self.fullText,
-             'parts': [part._as_dict_() for part in self.parts] if self.parts else None})
-    
-    def _fulltext_parts(self):
-        pass
-
-class Name(Conclusion):
-    identifier = 'http://gedcomx.org/v1/Name'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    @staticmethod
-    def simple(text: str):
-        """
-        Takes a string and returns a GedcomX Name Object
-        """
-        if text:
-            text = text.replace("/","")
-            parts = text.rsplit(' ', 1)
-        
-            # Assign val1 and val2 based on the split
-            given = parts[0] if len(parts) > 1 else ""
-            surname = parts[1] if len(parts) > 1 else parts[0]
-            
-            # Remove any '/' characters from both val1 and val2
-            #given = given.replace('/', '')
-            #surname = surname.replace('/', '')
-
-            given_name_part = NamePart(type = NamePartType.Given, value=given)
-            surname_part = NamePart(type = NamePartType.Surname, value=surname)
-
-            name_form = NameForm(fullText=text,parts=[given_name_part,surname_part])
-            name = Name(type=NameType.BirthName,nameForms=[name_form])
-        else:
-            name = Name()
-        return name
-
-    def __init__(self, id: str = None,
-                 lang: str = 'en',
-                 sources: Optional[List[SourceReference]] = None,
-                 analysis: Resource = None,
-                 notes: Optional[List[Note]] = None,
-                 confidence: Optional[ConfidenceLevel] = None,
-                 attribution: Optional[Attribution] = None,
-                 type: Optional[NameType] = None,
-                 nameForms: Optional[List[NameForm]]= None,
-                 date: Optional[Date] = None) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
-        self.type = type
-        self.nameForms = nameForms if nameForms else []
-        self.date = date
-    
-    def _add_name_part(self, namepart_to_add: NamePart):
-        if namepart_to_add and isinstance(namepart_to_add, NamePart):
-            for current_namepart in self.nameForms[0].parts:
-                if namepart_to_add == current_namepart:
-                    return False
-            self.nameForms[0].parts.append(namepart_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
-            
-        name_as_dict = super()._as_dict_
-
-        name_as_dict.update( {
-            'type':self.type.value if self.type else None,
-            'nameForms': [nameForm._as_dict_ for nameForm in self.nameForms],
-            'date': self.date._as_dict_ if self.date else None})
-        
-        #del name_as_dict['id']
-        # Serialize and exclude None values
-        for key, value in name_as_dict.items():
-            if value is not None:
-                name_as_dict[key] = _serialize(value)
-
-        # 3) merge and filter out None *at the top level*
-        return {
-            k: v
-            for k, v in name_as_dict.items()
-            if v is not None
-        }
-    
-        return name_as_dict
-
-class QuickName():
-    def __new__(cls,name: str) -> Name:
-        obj = Name(nameForms=[NameForm(fullText=name)])
-        return obj
-    
-def ensure_list(val):
-    if val is None:
-        return []
-    return val if isinstance(val, list) else [val]
-    
-NamePart._from_json_ = classmethod(lambda cls, data: NamePart(
-    type=NamePartType(data['type']) if 'type' in data else None,
-    value=data.get('value'),
-    qualifiers=[NamePartQualifier(q) for q in ensure_list(data.get('qualifiers'))]
-))
-
-NamePart._to_dict_ = lambda self: {
-    'type': self.type.value if self.type else None,
-    'value': self.value,
-    'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
-}
-
-
-# NameForm
-NameForm._from_json_ = classmethod(lambda cls, data: NameForm(
-    lang=data.get('lang', 'en'),
-    fullText=data.get('fullText'),
-    parts=[NamePart._from_json_(p) for p in ensure_list(data.get('parts'))]
-))
-
-NameForm._to_dict_ = lambda self: {
-    'lang': self.lang,
-    'fullText': self.fullText,
-    'parts': [p._to_dict_() for p in self.parts] if self.parts else []
-}
-
-
-# Name
-Name._from_json_ = classmethod(lambda cls, data: cls(
-    id=data.get('id'),
-    lang=data.get('lang', 'en'),
-    sources=[SourceReference._from_json_(s) for s in ensure_list(data.get('sources'))],
-    analysis=Resource._from_json_(data['analysis']) if data.get('analysis') else None,
-    notes=[Note._from_json_(n) for n in ensure_list(data.get('notes'))],
-    confidence=ConfidenceLevel._from_json_(data['confidence']) if data.get('confidence') else None,
-    attribution=Attribution._from_json_(data['attribution']) if data.get('attribution') else None,
-    type=NameType(data['type']) if data.get('type') else None,
-    nameForms=[NameForm._from_json_(nf) for nf in ensure_list(data.get('nameForms'))],
-    date=Date._from_json_(data['date']) if data.get('date') else None
-))
-
-
-

gedcomx/PlaceDescription.py

@@ -1,70 +0,0 @@
-from typing import List, Optional
-
-from .Attribution import Attribution
-from .Conclusion import ConfidenceLevel
-from .Date import Date
-from .EvidenceReference import EvidenceReference
-from .Identifier import IdentifierList
-from .Note import Note
-from .SourceReference import SourceReference
-from .TextValue import TextValue
-from .Resource import Resource
-from .Serialization import Serialization
-from .Subject import Subject
-from .URI import URI
-
-class PlaceDescription(Subject):
-    identifier = "http://gedcomx.org/v1/PlaceDescription"
-    version = 'http://gedcomx.org/conceptual-model/v1'
-
-    def __init__(self, id: Optional[str] =None,
-                 lang: str = 'en',
-                 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[IdentifierList] = None,
-                 names: Optional[List[TextValue]] = None,
-                 type: Optional[str] = None,
-                 place: Optional[URI] = None,
-                 jurisdiction: Optional["Resource | PlaceDescription"] = None, # PlaceDescription
-                 latitude: Optional[float] = None,
-                 longitude: Optional[float] = None,
-                 temporalDescription: Optional[Date] = None,
-                 spatialDescription: Optional[Resource] = 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
-
-    @property
-    def _as_dict_(self):
-        type_as_dict = super()._as_dict_
-        type_as_dict.update({
-            "names": [n for n in self.names] if self.names else None,
-            "type": self.type if self.type else None,
-            "place": self.place._as_dict_ if self.place else None,
-            "jurisdiction": self.jurisdiction._as_dict_ if self.jurisdiction else None,
-            "latitude": float(self.latitide) if self.latitide else None,
-            "longitude": float(self.longitute) if self.longitute else None,
-            "temporalDescription": self.temporalDescription if self.temporalDescription else None,
-            "spatialDescription": self.spacialDescription._as_dict_ if self.spacialDescription else None            
-        })
-        return Serialization.serialize_dict(type_as_dict) 
-
-    @classmethod
-    def _from_json_(cls, data: dict):
-        """
-        Create a PlaceDescription instance from a JSON-dict (already parsed).
-        """
-        return Serialization.deserialize(data, PlaceDescription)   

gedcomx/PlaceReference.py

@@ -1,30 +0,0 @@
-from typing import Optional
-
-from .Resource import Resource
-from .Serialization import Serialization
-
-class PlaceReference:
-    identifier = 'http://gedcomx.org/v1/PlaceReference'
-    version = 'http://gedcomx.org/conceptual-model/v1'
-    
-    def __init__(self,
-                 original: Optional[str] = None,
-                 description: Optional[Resource] = None) -> None:
-        self.original = original
-        self.description = description
-
-    @property
-    def _as_dict_(self):
-        type_as_dict = {
-            'original': self.original,
-            'description': self.description._as_dict_ if self.description else None
-            } 
-        return Serialization.serialize_dict(type_as_dict)
-    
-    @classmethod
-    def _from_json_(cls, data):
-        
-        return Serialization.deserialize(data, PlaceReference)
-
-
-

gedcomx/Qualifier.py

@@ -1,27 +0,0 @@
-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')
-))
-