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

gedcomx/Gender.py

@@ -9,7 +9,7 @@ from gedcomx.Resource import Resource
 
 from .Conclusion import Conclusion
 from .Qualifier import Qualifier
-from .Serialization import Serialization
+
 
 from collections.abc import Sized
 
@@ -35,7 +35,7 @@ class Gender(Conclusion):
 
     def __init__(self,
                  id: Optional[str] = None,
-                 lang: Optional[str] = 'en',
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = None,
@@ -48,19 +48,17 @@ class Gender(Conclusion):
     
     @property
     def _as_dict_(self):
+        from .Serialization import Serialization    
+        type_as_dict = super()._as_dict_  
+        if self.type:
+            type_as_dict['type'] = self.type.value if self.type else None                   
         
-            
-        type_as_dict = super()._as_dict_  # Start with base class fields
-        # Only add Relationship-specific fields
-        type_as_dict.update({
-            'type':self.type.value if self.type else None
-                           
-        })
         
         return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls,data):
+        from .Serialization import Serialization
         
         return Serialization.deserialize(data, Gender)
         

gedcomx/Identifier.py

@@ -26,11 +26,12 @@ def make_uid(length: int = 10, alphabet: str = string.ascii_letters + string.dig
     """
     if length <= 0:
         raise ValueError("length must be > 0")
-    return ''.join(secrets.choice(alphabet) for _ in range(length))
+    return ''.join(secrets.choice(alphabet) for _ in range(length)).upper()
 
 class IdentifierType(ExtensibleEnum):
-    """Enumeration of identifier types."""
     pass
+
+"""Enumeration of identifier types."""
 IdentifierType.register("Primary", "http://gedcomx.org/Primary")
 IdentifierType.register("Authority", "http://gedcomx.org/Authority")            
 IdentifierType.register("Deprecated", "http://gedcomx.org/Deprecated")
@@ -42,7 +43,7 @@ class Identifier:
     identifier = 'http://gedcomx.org/v1/Identifier'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, value: Optional[List[URI]], type: Optional[IdentifierType] = IdentifierType.Primary) -> None:
+    def __init__(self, value: Optional[List[URI]], type: Optional[IdentifierType] = IdentifierType.Primary) -> None: # type: ignore
         if not isinstance(value,list):
             value = [value] if value else []
         self.type = type
@@ -51,11 +52,11 @@ class Identifier:
     @property
     def _as_dict_(self):
         from .Serialization import Serialization
-        type_as_dict = {
-            'value': [v for v in self.values] if self.values else None,
-            'type': self.type.value if self.type else None
-                           
-        }
+        type_as_dict = {}
+        if self.values:
+            type_as_dict["value"] = list(self.values)  # or [v for v in self.values]
+        if self.type:
+            type_as_dict["type"] = getattr(self.type, "value", self.type)  # type: ignore[attr-defined]
 
         return Serialization.serialize_dict(type_as_dict)
 
@@ -64,10 +65,6 @@ class Identifier:
         """
         Construct an Identifier from a dict parsed from JSON.
         """
-        #for name, member in IdentifierType.__members__.items():
-        #    print(name)
-
-        
         
         for key in data.keys():
             type = key

gedcomx/LoggingHub.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 import logging
 import contextvars
+import os
 from contextlib import contextmanager
 from dataclasses import dataclass
 from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
@@ -184,3 +185,23 @@ class LoggingHub:
     # -------- Utilities --------
     def set_default_channel(self, name: str) -> None:
         self._dispatch.set_default_channel(name)
+
+hub = LoggingHub("gedcomx")     # this becomes your app logger root
+hub.init_root()                 # do this ONCE at startup
+
+os.makedirs("logs", exist_ok=True)
+
+# 1) Start a default channel (file w/ daily rotation)
+hub.start_channel(
+    ChannelConfig(
+        name="default",
+        path="logs/app.log",
+        level=logging.INFO,
+        fmt="[%(asctime)s] %(levelname)s %(log_channel)s %(name)s: %(message)s",
+        rotation="time:midnight:7",
+    ),
+    make_current=True
+)
+
+# (optional) Also a console channel you can switch to
+hub.start_channel(ChannelConfig(name="console", path=None, level=logging.DEBUG))

gedcomx/Mutations.py

@@ -1,4 +1,4 @@
-from .Gedcom5x import GedcomRecord
+from .Gedcom5x import Gedcom5xRecord
 from .Fact import Fact, FactType
 from .Event import Event, EventType
 
@@ -178,13 +178,13 @@ fact_event_table = {
 }
 
 class GedcomXObject:
-    def __init__(self,record: GedcomRecord | None = None) -> None:
-        self.created_with_tag: str = record.tag if record and isinstance(record, GedcomRecord) else None    
-        self.created_at_level: int = record.level if record and isinstance(record, GedcomRecord) else None
-        self.created_at_line_number: int = record.line_number if record and isinstance(record, GedcomRecord) else None
+    def __init__(self,record: Gedcom5xRecord | None = None) -> None:
+        self.created_with_tag: str = record.tag if record and isinstance(record, Gedcom5xRecord) else None    
+        self.created_at_level: int = record.level if record and isinstance(record, Gedcom5xRecord) else None
+        self.created_at_line_number: int = record.line_number if record and isinstance(record, Gedcom5xRecord) else None
 
 class GedcomXSourceOrDocument(GedcomXObject):
-    def __init__(self,record: GedcomRecord | None = None) -> None:
+    def __init__(self,record: Gedcom5xRecord | None = None) -> None:
         super().__init__(record)
         self.title: str = None
         self.citation: str = None
@@ -204,7 +204,7 @@ class GedcomXSourceOrDocument(GedcomXObject):
         self.description: str = None
 
 class GedcomXEventOrFact(GedcomXObject):
-    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+    def __new__(cls,record: Gedcom5xRecord | None = None, object_stack: dict | None = None) -> object:
         super().__init__(record)
         if record.tag in fact_event_table.keys():
 
@@ -219,7 +219,7 @@ class GedcomXEventOrFact(GedcomXObject):
             raise ValueError(f"{record.tag} not found in map")
 
 class GedcomXRelationshipBuilder(GedcomXObject):
-    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+    def __new__(cls,record: Gedcom5xRecord | None = None, object_stack: dict | None = None) -> object:
         last_relationship = object_stack.get('lastrelationship',None)
         last_relationship_data = object_stack.get('lastrelationshipdata',None)
         if not isinstance(last_relationship_data,dict):

gedcomx/Name.py

@@ -2,13 +2,33 @@ from enum import Enum
 from typing import List,Optional
 from typing_extensions import Self
 
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    Name.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX Name, NameType, NameForm, NamePart Types
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+#======================================================================
 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
+from .SourceReference import SourceReference
+#======================================================================
 
 
 class NameType(Enum):
@@ -90,22 +110,57 @@ class NamePartType(Enum):
         return descriptions.get(self, "No description available.")
     
 class NamePart:
+    """Used to model a portion of a full name
+        including the terms that make up that portion. Some name parts may have qualifiers
+        to provide additional semantic meaning to the name part (e.g., "given name" or "surname").
+
+    Args:
+        type (NamePartType | None): Classification of this component of the name
+            (e.g., ``Given``, ``Surname``, ``Prefix``, ``Suffix``, ``Title``, ``Particle``).
+        value (str): The textual value for this part, without surrounding
+            punctuation (e.g., ``"John"``, ``"van"``, ``"III"``).
+        qualifiers (list[NamePartQualifier] | None): Optional qualifiers that refine
+            the meaning or usage of this part (e.g., language/script variants, initials).
+
+    Examples:
+        >>> from gedcomx.Name import *
+        >>> typ = NamePartType.Given
+        >>> given = "Moses"
+        >>> q = NamePartQualifier.Primary
+        >>> name = NamePart(type=typ,value=given,qualifiers=[q])
+        >>> print(name)
+        NamePart(type=Given, value='Moses', qualifiers=1)
+
+    """
     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:
+                 qualifiers: Optional[List[NamePartQualifier]] = None) -> None:
         self.type = type
         self.value = value
-        self.qualifiers = qualifiers
+        self.qualifiers = qualifiers if qualifiers else []
     
+    @property
     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})
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.type:
+            type_as_dict['type'] = self.type.value
+        if self.value:
+            type_as_dict['value'] = self.value
+        if self.qualifiers:
+            type_as_dict['qualifiers'] = [q.value for q in self.qualifiers]
+        Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls,data):
+        name_part =NamePart(type=NamePartType(data['type']) if 'type' in data else None,
+                            value=data.get('value'),
+                            qualifiers=[NamePartQualifier(q) for q in data.get('qualifiers')])
+        return name_part
 
     def __eq__(self, other):
         if not isinstance(other, NamePart):
@@ -114,26 +169,114 @@ class NamePart:
                 self.value == other.value and
                 self.qualifiers == other.qualifiers)    
 
+    def __str__(self) -> str:
+        parts = []
+        if self.type is not None:
+            parts.append(f"type={getattr(self.type, 'name', str(self.type))}")
+        if self.value is not None:
+            parts.append(f"value={self.value!r}")
+        if self.qualifiers:
+            parts.append(f"qualifiers={len(self.qualifiers)}")
+        return f"NamePart({', '.join(parts)})" if parts else "NamePart()"
+
+    def __repr__(self) -> str:
+        if self.type is not None:
+            tcls = self.type.__class__.__name__
+            tname = getattr(self.type, "name", str(self.type))
+            tval = getattr(self.type, "value", self.type)
+            type_repr = f"<{tcls}.{tname}: {tval!r}>"
+        else:
+            type_repr = "None"
+        return (
+            f"{self.__class__.__name__}("
+            f"type={type_repr}, "
+            f"value={self.value!r}, "
+            f"qualifiers={self.qualifiers!r})"
+        )
+
 class NameForm:
+    """A representation of a name (a "name form") 
+        within a given cultural context, such as a given language and script.
+        As names are captured (both in records or in applications), the terms
+        in the name are sometimes classified by type. For example, a certificate
+        of death might prompt for **"given name(s)"** and **"surname"**. The parts
+        list can be used to represent the terms in the name that have been classified.
+
+    Args:
+        lang (str | None): BCP-47 language tag for this name form (e.g., "en").
+        fullText (str | None): The full, unparsed name string as written in the source.
+            If provided, the name SHOULD be rendered as it would normally be spoken in
+            the applicable cultural context.
+        parts (list[NamePart] | None): Ordered structured components of the name
+            (e.g., Given, Surname). If provided, ``fullText`` may be omitted. If
+            provided, the list SHOULD be ordered such that the parts are in the order
+            they would normally be spoken in the applicable cultural context.
+
+    """
     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:
+    def __init__(self, lang: Optional[str] = None,
+                 fullText: Optional[str] = None,
+                 parts: Optional[List[NamePart]] = None) -> None:
+        
         self.lang = lang
         self.fullText = fullText
-        self.parts = parts
+        self.parts = parts if parts else []
     
     @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})
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.lang:
+            type_as_dict['lang'] = self.lang
+        if self.fullText:
+            type_as_dict['fullText'] = self.fullText
+        if self.parts:
+            type_as_dict['parts'] = [part._as_dict_ for part in self.parts if part]
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict) -> "NameForm":
+        """Build a NameForm from JSON-like dict."""
+        return cls(
+            lang=data.get("lang", "en"),
+            fullText=data.get("fullText"),
+            parts=[NamePart._from_json_(p) for p in ensure_list(data.get("parts"))],
+        )
     
     def _fulltext_parts(self):
         pass
 
 class Name(Conclusion):
+    """**Defines a name of a person.**
+
+            A Name is intended to represent a single variant of a person's name. 
+            This means that nicknames, spelling variations, or other names 
+            (often distinguishable by a name type) should be modeled with 
+            separate instances of Name.
+
+    .. admonition:: Advanced details
+        :class: toggle
+    
+        The name forms of a name contain alternate representations of the name.
+        A Name MUST contain at least one name form, presumably a representation
+        of the name that is considered proper and well formed in the person's native,
+        historical cultural context. Other name forms MAY be included, which can be
+        used to represent this name in contexts where the native name form is not easily
+        recognized and interpreted. Alternate forms are more likely in situations where
+        conclusions are being analyzed across cultural context boundaries that have both
+        language and writing script differences.
+        
+
+    Attributes:
+        type (Optional[:class:`~gedcomx.NameType`]): Classification of the name
+            (e.g., BirthName, AlsoKnownAs).
+        nameForms (List[:class:`~gedcomx.NameForm`]): One or more structured
+            representations of the name (full text and parts).
+        date (Optional[:class:`~gedcomx.Date`]): Date context for this name
+            (e.g., when the name was used or recorded).
+    """
     identifier = 'http://gedcomx.org/v1/Name'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -163,8 +306,8 @@ class Name(Conclusion):
             name = Name()
         return name
 
-    def __init__(self, id: str = None,
-                 lang: str = 'en',
+    def __init__(self, id: Optional[str] = None,
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Resource = None,
                  notes: Optional[List[Note]] = None,
@@ -187,39 +330,52 @@ class Name(Conclusion):
     
     @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})
+        from .Serialization import Serialization
+        type_as_dict = super()._as_dict_
+        if self.type:
+            type_as_dict['type'] = getattr(self.type, 'value', self.type)
+        if self.nameForms:
+            type_as_dict['nameForms'] = [nf._as_dict_ for nf in self.nameForms if nf]
+        if self.date:
+            type_as_dict['date'] = self.date._as_dict_
         
-        #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 Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict) -> "Name":
+        """Build a Name from JSON-like dict."""
+        return 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,
+        )
     
-        return name_as_dict
+    def __str__(self) -> str:
+        """Return a human-readable string for the Name-like object."""
+        return f"Name(id={self.id}, type={self.type}, forms={len(self.nameForms)}, date={self.date})"
+
+    def __repr__(self) -> str:
+        """Return an unambiguous string representation of the Name-like object."""
+        return (
+            f"{self.__class__.__name__}("
+            f"id={self.id!r}, "
+            f"lang={self.lang!r}, "
+            f"sources={self.sources!r}, "
+            f"analysis={self.analysis!r}, "
+            f"notes={self.notes!r}, "
+            f"confidence={self.confidence!r}, "
+            f"attribution={self.attribution!r}, "
+            f"type={self.type!r}, "
+            f"nameForms={self.nameForms!r}, "
+            f"date={self.date!r})"
+    )
 
 class QuickName():
     def __new__(cls,name: str) -> Name:
@@ -231,46 +387,10 @@ def ensure_list(val):
         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/Note.py

@@ -1,7 +1,6 @@
 from typing import Optional
 
 from .Attribution import Attribution
-from .Serialization import Serialization
 
 class Note:
     identifier = 'http://gedcomx.org/v1/Note'
@@ -15,20 +14,28 @@ class Note:
 
     def append(self, text_to_add: str):
         if text_to_add and isinstance(text_to_add, str):
-            self.text = self.text + text_to_add
+            if self.text:
+                self.text = self.text + text_to_add
+            else:
+                self.text = text_to_add
         else:
             return #TODO
             raise ValueError("The text to add must be a non-empty string.")
     
     @property
     def _as_dict_(self):
-        note_dict = {
-            "lang":self.lang if self.lang else None,
-            "subject":self.subject if self.subject else None,
-            "text":self.text if self.text else None,
-            "attribution": self.attribution if self.attribution else None
-        }
-        return Serialization.serialize_dict(note_dict)
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.lang:
+            type_as_dict["lang"] = self.lang
+        if self.subject:
+            type_as_dict["subject"] = self.subject
+        if self.text:
+            type_as_dict["text"] = self.text
+        if self.attribution:
+            # If attribution exposes `_as_dict_` as a property, use it; otherwise include as-is
+            type_as_dict["attribution"] = getattr(self.attribution, "_as_dict_", self.attribution)
+        return Serialization.serialize_dict(type_as_dict)    
     
     def __eq__(self, other):
         if not isinstance(other, Note):