gedcom-x 0.5.5__tar.gz → 0.5.6__tar.gz

gedcom_x-0.5.6/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: gedcom-x
+Version: 0.5.6
+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 Python Toolkit (gedcom-x beta 0.5.5)
+
+A lightweight, class-based Python implementation of the [GEDCOM-X data model](https://github.com/FamilySearch/gedcomx).  
+
+## ⚠️ Project Status
+
+This project is currently in **beta**.  
+While the core GEDCOM-X classes and serialization are functional, some features may not be fully implemented or may not behave exactly as expected.  
+
+- Certain GEDCOM 7 tags are not yet mapped  
+- Some classes may be missing methods or fields  
+- Error handling and validation are still evolving  
+- Backward compatibility is **not guaranteed** until the first stable release  
+
+### ✅ What You Can Do
+- Create and manipulate GEDCOM-X objects in Python  
+- Serialize and deserialize data to/from JSON  
+- Experimentally convert GEDCOM 5x & 7 files into GEDCOM-X JSON  
+- Extend the classes to handle new GEDCOM tags or custom attributes  
+- Use the library as a foundation for genealogy-related tooling or RAG pipelines  
+
+### ❌ What You Can’t Do (Yet)
+- Rely on complete coverage of all GEDCOM 7 tags  
+- Expect perfect compliance with the GEDCOM-X specification  
+- Assume strong validation or error recovery on malformed input  
+- Use it as a drop-in replacement for production genealogy software  
+- Write GEDCOM-X to GEDCOM 5x / 7
+- Create Graphs from Genealogies
+
+Contributors and testers are welcome — feedback will help stabilize the library!
+
+---
+
+This library aims to provide:
+
+- Python classes for every GEDCOM-X type (Person, Fact, Source, etc.)
+- Extensibility, with current GEDCOM RS etc, extension built in
+- Serialization and Deserialization to/from GEDCOM-X JSON
+- Utilities to convert GEDCOM 5x & 7 GEDCOM Files into GEDCOM-X and back
+- Type-safe field definitions and extensibility hooks for future tags
+
+---
+
+## Features
+
+- **Complete GEDCOM-X Class Coverage**  
+  Each GEDCOM-X type is represented as a Python class with fields and types.
+
+- **Serialization / Deserialization**  
+  Every class can serialize to JSON and reconstruct from JSON via `_as_dict_()` and `_from_json()` methods.
+
+- **Type Checking & Enum Validation**  
+  Uses Python type hints and enums to ensure correct values (e.g. FactType, EventType, ConfidenceLevel).
+
+- **Composable / Nestable Classes**  
+  Nested objects (e.g. Person → Name → NameForm → TextValue) are constructed and validated recursively.
+
+- **GEDCOM 7 → GEDCOM-X Conversion**  
+  Experimental parser to read GEDCOM 7 files and convert them into structured GEDCOM-X JSON.
+
+---
+
+## Installation
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://github.com/yourusername/gedcom-x.git
+cd gedcom-x
+pip install -r requirements.txt
+```
+or
+```
+pip install gedcom-x
+```
+---
+
+## Examples
+
+<details>
+
+<summary>Create a Person Gedcom-X Type</summary>
+
+```python
+import json
+from gedcomx import Person, Name, NameForm, TextValue
+
+person = Person(
+    id="P-123",
+    names=[Name(
+        nameForms=[NameForm(
+            fullText=TextValue(value="John Doe")
+        )]
+    )]
+)
+
+print(json.dumps(person._as_dict_,indent=4))
+```
+result
+```text
+{
+    "id": "P-123",
+    "lang": "en",
+    "private": false,
+    "living": false,
+    "gender": {
+        "lang": "en",
+        "type": "http://gedcomx.org/Unknown"
+    },
+    "names": [
+        {
+            "lang": "en",
+            "nameForms": [
+                {
+                    "lang": "en",
+                    "fullText": {
+                        "lang": "en",
+                        "value": "John Doe"
+                    }
+                }
+            ]
+        }
+    ]
+}
+
+</details>

gedcom_x-0.5.6/README.md

@@ -0,0 +1,126 @@
+# GEDCOM-X Python Toolkit (gedcom-x beta 0.5.5)
+
+A lightweight, class-based Python implementation of the [GEDCOM-X data model](https://github.com/FamilySearch/gedcomx).  
+
+## ⚠️ Project Status
+
+This project is currently in **beta**.  
+While the core GEDCOM-X classes and serialization are functional, some features may not be fully implemented or may not behave exactly as expected.  
+
+- Certain GEDCOM 7 tags are not yet mapped  
+- Some classes may be missing methods or fields  
+- Error handling and validation are still evolving  
+- Backward compatibility is **not guaranteed** until the first stable release  
+
+### ✅ What You Can Do
+- Create and manipulate GEDCOM-X objects in Python  
+- Serialize and deserialize data to/from JSON  
+- Experimentally convert GEDCOM 5x & 7 files into GEDCOM-X JSON  
+- Extend the classes to handle new GEDCOM tags or custom attributes  
+- Use the library as a foundation for genealogy-related tooling or RAG pipelines  
+
+### ❌ What You Can’t Do (Yet)
+- Rely on complete coverage of all GEDCOM 7 tags  
+- Expect perfect compliance with the GEDCOM-X specification  
+- Assume strong validation or error recovery on malformed input  
+- Use it as a drop-in replacement for production genealogy software  
+- Write GEDCOM-X to GEDCOM 5x / 7
+- Create Graphs from Genealogies
+
+Contributors and testers are welcome — feedback will help stabilize the library!
+
+---
+
+This library aims to provide:
+
+- Python classes for every GEDCOM-X type (Person, Fact, Source, etc.)
+- Extensibility, with current GEDCOM RS etc, extension built in
+- Serialization and Deserialization to/from GEDCOM-X JSON
+- Utilities to convert GEDCOM 5x & 7 GEDCOM Files into GEDCOM-X and back
+- Type-safe field definitions and extensibility hooks for future tags
+
+---
+
+## Features
+
+- **Complete GEDCOM-X Class Coverage**  
+  Each GEDCOM-X type is represented as a Python class with fields and types.
+
+- **Serialization / Deserialization**  
+  Every class can serialize to JSON and reconstruct from JSON via `_as_dict_()` and `_from_json()` methods.
+
+- **Type Checking & Enum Validation**  
+  Uses Python type hints and enums to ensure correct values (e.g. FactType, EventType, ConfidenceLevel).
+
+- **Composable / Nestable Classes**  
+  Nested objects (e.g. Person → Name → NameForm → TextValue) are constructed and validated recursively.
+
+- **GEDCOM 7 → GEDCOM-X Conversion**  
+  Experimental parser to read GEDCOM 7 files and convert them into structured GEDCOM-X JSON.
+
+---
+
+## Installation
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://github.com/yourusername/gedcom-x.git
+cd gedcom-x
+pip install -r requirements.txt
+```
+or
+```
+pip install gedcom-x
+```
+---
+
+## Examples
+
+<details>
+
+<summary>Create a Person Gedcom-X Type</summary>
+
+```python
+import json
+from gedcomx import Person, Name, NameForm, TextValue
+
+person = Person(
+    id="P-123",
+    names=[Name(
+        nameForms=[NameForm(
+            fullText=TextValue(value="John Doe")
+        )]
+    )]
+)
+
+print(json.dumps(person._as_dict_,indent=4))
+```
+result
+```text
+{
+    "id": "P-123",
+    "lang": "en",
+    "private": false,
+    "living": false,
+    "gender": {
+        "lang": "en",
+        "type": "http://gedcomx.org/Unknown"
+    },
+    "names": [
+        {
+            "lang": "en",
+            "nameForms": [
+                {
+                    "lang": "en",
+                    "fullText": {
+                        "lang": "en",
+                        "value": "John Doe"
+                    }
+                }
+            ]
+        }
+    ]
+}
+
+</details>

gedcom_x-0.5.6/gedcom_x.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: gedcom-x
+Version: 0.5.6
+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 Python Toolkit (gedcom-x beta 0.5.5)
+
+A lightweight, class-based Python implementation of the [GEDCOM-X data model](https://github.com/FamilySearch/gedcomx).  
+
+## ⚠️ Project Status
+
+This project is currently in **beta**.  
+While the core GEDCOM-X classes and serialization are functional, some features may not be fully implemented or may not behave exactly as expected.  
+
+- Certain GEDCOM 7 tags are not yet mapped  
+- Some classes may be missing methods or fields  
+- Error handling and validation are still evolving  
+- Backward compatibility is **not guaranteed** until the first stable release  
+
+### ✅ What You Can Do
+- Create and manipulate GEDCOM-X objects in Python  
+- Serialize and deserialize data to/from JSON  
+- Experimentally convert GEDCOM 5x & 7 files into GEDCOM-X JSON  
+- Extend the classes to handle new GEDCOM tags or custom attributes  
+- Use the library as a foundation for genealogy-related tooling or RAG pipelines  
+
+### ❌ What You Can’t Do (Yet)
+- Rely on complete coverage of all GEDCOM 7 tags  
+- Expect perfect compliance with the GEDCOM-X specification  
+- Assume strong validation or error recovery on malformed input  
+- Use it as a drop-in replacement for production genealogy software  
+- Write GEDCOM-X to GEDCOM 5x / 7
+- Create Graphs from Genealogies
+
+Contributors and testers are welcome — feedback will help stabilize the library!
+
+---
+
+This library aims to provide:
+
+- Python classes for every GEDCOM-X type (Person, Fact, Source, etc.)
+- Extensibility, with current GEDCOM RS etc, extension built in
+- Serialization and Deserialization to/from GEDCOM-X JSON
+- Utilities to convert GEDCOM 5x & 7 GEDCOM Files into GEDCOM-X and back
+- Type-safe field definitions and extensibility hooks for future tags
+
+---
+
+## Features
+
+- **Complete GEDCOM-X Class Coverage**  
+  Each GEDCOM-X type is represented as a Python class with fields and types.
+
+- **Serialization / Deserialization**  
+  Every class can serialize to JSON and reconstruct from JSON via `_as_dict_()` and `_from_json()` methods.
+
+- **Type Checking & Enum Validation**  
+  Uses Python type hints and enums to ensure correct values (e.g. FactType, EventType, ConfidenceLevel).
+
+- **Composable / Nestable Classes**  
+  Nested objects (e.g. Person → Name → NameForm → TextValue) are constructed and validated recursively.
+
+- **GEDCOM 7 → GEDCOM-X Conversion**  
+  Experimental parser to read GEDCOM 7 files and convert them into structured GEDCOM-X JSON.
+
+---
+
+## Installation
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://github.com/yourusername/gedcom-x.git
+cd gedcom-x
+pip install -r requirements.txt
+```
+or
+```
+pip install gedcom-x
+```
+---
+
+## Examples
+
+<details>
+
+<summary>Create a Person Gedcom-X Type</summary>
+
+```python
+import json
+from gedcomx import Person, Name, NameForm, TextValue
+
+person = Person(
+    id="P-123",
+    names=[Name(
+        nameForms=[NameForm(
+            fullText=TextValue(value="John Doe")
+        )]
+    )]
+)
+
+print(json.dumps(person._as_dict_,indent=4))
+```
+result
+```text
+{
+    "id": "P-123",
+    "lang": "en",
+    "private": false,
+    "living": false,
+    "gender": {
+        "lang": "en",
+        "type": "http://gedcomx.org/Unknown"
+    },
+    "names": [
+        {
+            "lang": "en",
+            "nameForms": [
+                {
+                    "lang": "en",
+                    "fullText": {
+                        "lang": "en",
+                        "value": "John Doe"
+                    }
+                }
+            ]
+        }
+    ]
+}
+
+</details>

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/gedcom_x.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+README.md
 pyproject.toml
 setup.py
 gedcom_x.egg-info/PKG-INFO
@@ -14,6 +15,7 @@ gedcomx/Document.py
 gedcomx/Event.py
 gedcomx/EvidenceReference.py
 gedcomx/Exceptions.py
+gedcomx/ExtensibleEnum.py
 gedcomx/Fact.py
 gedcomx/Gedcom.py
 gedcomx/Gedcom5x.py
@@ -22,6 +24,7 @@ gedcomx/Gender.py
 gedcomx/Group.py
 gedcomx/Identifier.py
 gedcomx/Logging.py
+gedcomx/LoggingHub.py
 gedcomx/Mutations.py
 gedcomx/Name.py
 gedcomx/Note.py

gedcom_x-0.5.6/gedcomx/ExtensibleEnum.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, Literal
+
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    ExtensibleEnum.py
+ Author:  David J. Cartwright
+ Purpose: Create a class that can act like an enum but be extended by the user at runtime.
+
+ Created: 2025-08-25
+ Updated:
+   - YYYY-MM-DD: <change description>
+   
+======================================================================
+"""
+
+@dataclass(frozen=True, slots=True)
+class _EnumItem:
+    """
+    A single registered member of an :class:`ExtensibleEnum`.
+
+    Each `_EnumItem` represents one (name, value) pair that belongs
+    to a particular `ExtensibleEnum` subclass. Items are immutable
+    once created.
+
+    Attributes
+    ----------
+    owner : type
+        The subclass of :class:`ExtensibleEnum` that owns this member
+        (e.g., `Color`).
+    name : str
+        The symbolic name of the member (e.g., `"RED"`).
+    value : Any
+        The underlying value associated with the member (e.g., `"r"`).
+
+    Notes
+    -----
+    - Equality is determined by object identity (not overridden).
+    - Instances are hashable by default since the dataclass is frozen.
+    - The `__repr__` and `__str__` provide user-friendly string forms.
+
+    Examples
+    --------
+    >>> class Color(ExtensibleEnum): ...
+    >>> red = Color.register("RED", "r")
+    >>> repr(red)
+    'Color.RED'
+    >>> str(red)
+    'RED'
+    >>> red.value
+    'r'
+    """
+    owner: type
+    name: str
+    value: Any
+    def __repr__(self) -> str:  # print(...) shows "Color.RED"
+        return f"{self.owner.__name__}.{self.name}"
+    def __str__(self) -> str:
+        return self.name
+
+class _ExtEnumMeta(type):
+    def __iter__(cls) -> Iterator[_EnumItem]:
+        return iter(cls._members.values())
+    def __contains__(cls, item: object) -> bool:
+        return item in cls._members.values()
+    # Support Color('RED') / Color(2)
+    def __call__(cls, arg: Any, /, *, by: Literal["auto","name","value"]="auto") -> _EnumItem:
+        if isinstance(arg, _EnumItem):
+            if arg.owner is cls:
+                return arg
+            raise TypeError(f"{arg!r} is not a member of {cls.__name__}")
+        if by == "name":
+            return cls.get(str(arg))
+        if by == "value":
+            return cls.from_value(arg)
+        if isinstance(arg, str) and arg in cls._members:
+            return cls.get(arg)
+        return cls.from_value(arg)
+
+class ExtensibleEnum(metaclass=_ExtEnumMeta):
+    """
+    A lightweight, **runtime-extensible**, enum-like base class.
+
+    Subclass this to create an enum whose members can be registered at runtime.
+    Registered members are exposed as class attributes (e.g., `Color.RED`) and
+    can be retrieved by name (`Color.get("RED")`) or by value
+    (`Color.from_value("r")`). Square-bracket lookup (`Color["RED"]`) is also
+    supported via ``__class_getitem__``.
+
+    This is useful when:
+      - The full set of enum values is not known until runtime (plugins, config).
+      - You need attribute-style access (`Color.RED`) but want to add members
+        dynamically and/or validate uniqueness of names/values.
+
+    Notes
+    -----
+    - **Uniqueness:** Names and values are unique within a subclass.
+    - **Per-subclass registry:** Each subclass has its own member registry.
+    - **Thread safety:** Registration is **not** thread-safe. If multiple threads
+      may register members, wrap `register()` calls in your own lock.
+    - **Immutability:** Once registered, a member’s `name` and `value` are fixed.
+      Re-registering the same `name` with the *same* `value` returns the existing
+      item; a different value raises an error.
+
+    Examples
+    --------
+    Define an extensible enum and register members:
+
+    >>> class Color(ExtensibleEnum):
+    ...     pass
+    ...
+    >>> Color.register("RED", "r")
+    _EnumItem(owner=Color, name='RED', value='r')
+    >>> Color.register("GREEN", "g")
+    _EnumItem(owner=Color, name='GREEN', value='g')
+
+    Access members:
+
+    >>> Color.RED is Color.get("RED")
+    True
+    >>> Color["GREEN"] is Color.get("GREEN")
+    True
+    >>> Color.from_value("g") is Color.GREEN
+    True
+    >>> Color.names()
+    ['RED', 'GREEN']
+
+    Error cases:
+
+    >>> Color.register("RED", "different")  # doctest: +IGNORE_EXCEPTION_DETAIL
+    ValueError: name 'RED' already used with different value 'r'
+    >>> Color.get("BLUE")                    # doctest: +IGNORE_EXCEPTION_DETAIL
+    KeyError: Color has no member named 'BLUE'
+    >>> Color.from_value("b")                # doctest: +IGNORE_EXCEPTION_DETAIL
+    KeyError: Color has no member with value 'b'
+    """
+    """Runtime-extensible enum-like base."""
+    _members: Dict[str, _EnumItem] = {}
+
+    def __init_subclass__(cls, **kw):
+        super().__init_subclass__(**kw)
+        cls._members = {}  # fresh registry per subclass
+
+    @classmethod
+    def __class_getitem__(cls, key: str) -> _EnumItem:  # Color['RED']
+        return cls.get(key)
+
+    @classmethod
+    def register(cls, name: str, value: Any) -> _EnumItem:
+        if not isinstance(name, str) or not name.isidentifier():
+            raise ValueError("name must be a valid identifier")
+        if name in cls._members:
+            item = cls._members[name]
+            if item.value != value:
+                raise ValueError(f"name {name!r} already used with different value {item.value!r}")
+            return item
+        if any(m.value == value for m in cls._members.values()):
+            raise ValueError(f"value {value!r} already used")
+        item = _EnumItem(owner=cls, name=name, value=value)
+        cls._members[name] = item
+        setattr(cls, name, item)  # enables Color.RED attribute
+        return item
+
+    @classmethod
+    def names(cls) -> list[str]:
+        return list(cls._members.keys())
+
+    @classmethod
+    def get(cls, name: str) -> _EnumItem:
+        try:
+            return cls._members[name]
+        except KeyError as e:
+            raise KeyError(f"{cls.__name__} has no member named {name!r}") from e
+
+    @classmethod
+    def from_value(cls, value: Any) -> _EnumItem:
+        for m in cls._members.values():
+            if m.value == value:
+                return m
+        raise KeyError(f"{cls.__name__} has no member with value {value!r}")
+

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/gedcomx/Gedcom5x.py

@@ -8,6 +8,10 @@ import re
 from collections import defaultdict
 from typing import Iterable, Iterator, List, Optional, Tuple, Union
 
+from .LoggingHub import LoggingHub, ChannelConfig
+hub = LoggingHub("GEDCOM5x")
+hub.init_root()
+
 BOM = '\ufeff'
 
 GEDCOM7_LINE_RE = re.compile(
@@ -219,11 +223,14 @@ class Gedcom5x():
     _top_level_tags = ['INDI', 'FAM', 'OBJE', 'SOUR', 'REPO', 'NOTE', 'HEAD','SNOTE']
   
     def __init__(self, records: Optional[List[GedcomRecord]] = None,filepath: str = None) -> None:
+
+        self.records: List[GedcomRecord] = records or []
         if filepath:
             self.records = self._records_from_file(filepath)
         elif records:
             self.records: List[GedcomRecord] = records if records else []
         
+        
         # Fast tag index: {'HEAD': [rec], 'INDI': [rec1, rec2, ...], ...}
         self._tag_index: dict[str, List[GedcomRecord]] = defaultdict(list)
         self._reindex()
@@ -356,7 +363,7 @@ class Gedcom5x():
             value_width = max(len(str(value)) for _, value in pairs)
 
             # Print the header
-            print('GEDCOM Import Results')
+            print(f'GEDCOM {self.version} Import Results')
             header = f"{'Type'.ljust(name_width)} | {'Count'.ljust(value_width)}"
             print('-' * len(header))
             print(header)
@@ -430,8 +437,6 @@ class Gedcom5x():
             raise ValueError("objects must be a list of GedcomRecord objects.")
         self._objects = value
 
-    
-
     def write(self) -> bool:
         """
         Method placeholder for writing GEDCOM files.
@@ -444,7 +449,7 @@ class Gedcom5x():
         raise NotImplementedError("Writing of GEDCOM files is not implemented.")  
 
     @staticmethod
-    def _records_from_file(filepath: str) -> List[GedcomRecord]:
+    def _records_from_file(file_path: str) -> List[GedcomRecord]:
         def parse_gedcom7_line(line: str) -> Optional[Tuple[int, Optional[str], str, Optional[str], Optional[str]]]:
             """
             Parse a GEDCOM 7 line into: level, xref_id (record), tag, value, xref_value (if value is an @X@)
@@ -466,15 +471,15 @@ class Gedcom5x():
             return level, xref_id, tag, value, xref_value
         extension = '.ged'
 
-        if not os.path.exists(filepath):
-            print(f"File does not exist: {filepath}")
+        if not os.path.exists(file_path):
+            print(f"File does not exist: {file_path}")
             raise FileNotFoundError
-        elif not filepath.lower().endswith(extension.lower()):
-            print(f"File does not have the correct extension: {filepath}")
+        elif not file_path.lower().endswith(extension.lower()):
+            print(f"File does not have the correct extension: {file_path}")
             raise Exception("File does not appear to be a GEDCOM")
         
         print("Reading from GEDCOM file")
-        with open(filepath, 'r', encoding='utf-8') as file:
+        with open(file_path, 'r', encoding='utf-8') as file:
             lines = [line.strip() for line in file]
 
             records = []
@@ -528,7 +533,7 @@ class Gedcom5x():
         return records if records else None
 
     @staticmethod
-    def fromFile(filepath: str) -> 'Gedcom':
+    def fromFile(file_path: str) -> 'Gedcom':
         """
         Static method to create a Gedcom object from a GEDCOM file.
 
@@ -538,21 +543,37 @@ class Gedcom5x():
         Returns:
             Gedcom: An instance of the Gedcom class.
         """     
-        records = Gedcom._records_from_file(filepath)
+        records = Gedcom5x._records_from_file(file_path)
         
-        gedcom = Gedcom(records=records)      
+        gedcom = Gedcom5x(records=records)      
 
         return gedcom
     
-    def merge_with_file(self, file_path: str) -> bool:
-        """
-        Adds records from a valid (``*``.ged) file to the current Genealogy
-
-        Args:
-            filepath (str): The path to the GEDCOM file.
+    def load_file(self,file_path: str) -> None:
+        records = Gedcom5x._records_from_file(file_path)
+        if records:
+            self.records.extend(records)
+            for record in self.records:
+                if record.tag == 'HEAD':
+                    pass
+                    #self.header = record
+                    #version = record['GEDC']['VERS'].value
+                    #if not str(version)[0:2] == str(self.version)[0:2]: #TODO Deal with no VERS
+                    #    raise ValueError(f'Wrong Version Current: {str(version)[0:2]}, new file: {str(self.version)[0:2]}')
+                if record.tag == 'INDI':
+                    self._individuals.append(record)
+                if record.tag == 'SOUR' and record.level == 0:
+                    self._sources.append(record)
+                if record.tag == 'REPO' and record.level == 0:
+                    self._repositories.append(record)
+                if record.tag == 'FAM' and record.level == 0:
+                    self._families.append(record)
+                if record.tag == 'OBJE' and record.level == 0:
+                    self._objects.append(record)
+                if record.tag == 'SNOTE' and record.level == 0:
+                    record.xref = record.value
+                    self._snotes.append(record)
+        else:
+            raise ValueError()
 
-        Returns:
-            bool: Indicates if merge was successful.
-        """
-        return True
 

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/gedcomx/GedcomX.py

@@ -20,7 +20,7 @@ from .Exceptions import TagConversionError
 from .Event import Event,EventType,EventRole,EventRoleType
 from .Fact import Fact, FactType, FactQualifier
 from .Gedcom import Gedcom
-from .Gedcom5x import GedcomRecord
+from .Gedcom5x import Gedcom5x, GedcomRecord
 from .Gender import Gender, GenderType
 from .Group import Group
 from .Identifier import Identifier, IdentifierType, make_uid, IdentifierList
@@ -340,7 +340,8 @@ class GedcomX:
             if agent.id is None:
                 agent.id = Agent.default_id_generator()
             if self.agents.byId(agent.id):
-                raise ValueError
+                pass #TODO Deal with duplicates
+                #raise ValueError
             print(f'Added Agent with id: {agent.id}')
             self.agents.append(agent)
     
@@ -380,7 +381,7 @@ class GedcomX:
         return json.dumps(gedcomx_json, indent=4)
 
 class Translater():
-    def __init__(self,gedcom: Gedcom) -> None:
+    def __init__(self,gedcom: Gedcom5x) -> None:
         self.handlers = {}
         self.gedcom: Gedcom = gedcom
         self.gedcomx = GedcomX()
@@ -972,7 +973,7 @@ class Translater():
         elif record.parent.tag == 'TRAN':
             pass #TODO
         else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
+            convert_log.error(f"raise TagConversionError(record=record,levelstack=self.object_map")
 
     def handle_givn(self, record: GedcomRecord):
         if isinstance(self.object_map[record.level-1], Name):
@@ -1051,6 +1052,12 @@ class Translater():
                 self.object_map[record.level-1].changeMessage = record.value
             else:
                 self.object_map[record.level-1].changeMessage = self.object_map[record.level-1].changeMessage + '' + record.value
+        elif isinstance(self.object_map[record.level-1], Note):
+            gxobject = Note(text=Translater.clean_str(record.value))
+            self.object_map[record.level-2].add_note(gxobject)
+
+            self.object_stack.append(gxobject)
+            self.object_map[record.level] = gxobject
 
         else:
             raise ValueError(f"Could not handle 'NOTE' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
@@ -1306,7 +1313,7 @@ class Translater():
 
             self.object_map[record.level]._add_name_part(gxobject)
         else:
-            raise TagConversionError(record=record,levelstack=self.object_map)
+            convert_log.error(f"raise TagConversionError(record=record,levelstack=self.object_map)")
 
     def handle_tran(self, record: GedcomRecord):
         pass

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/gedcomx/Identifier.py

@@ -7,7 +7,7 @@ from collections.abc import Iterator
 import json
 from .Resource import Resource
 from .URI import URI
-from .Extensible.extensibles import ExtensibleEnum
+from .ExtensibleEnum import ExtensibleEnum
 
 import secrets
 import string

gedcom_x-0.5.6/gedcomx/LoggingHub.py

@@ -0,0 +1,186 @@
+# logging_hub.py
+from __future__ import annotations
+import logging
+import contextvars
+from contextlib import contextmanager
+from dataclasses import dataclass
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Dict, Optional
+
+# Context key: which "channel" (log) is current?
+_current_channel: contextvars.ContextVar[str] = contextvars.ContextVar("current_log_channel", default="default")
+
+def get_current_channel() -> str:
+    return _current_channel.get()
+
+def set_current_channel(name: str) -> None:
+    _current_channel.set(name)
+
+class ChannelFilter(logging.Filter):
+    """Injects the current channel into every LogRecord."""
+    def filter(self, record: logging.LogRecord) -> bool:
+        record.log_channel = get_current_channel()
+        return True
+
+class DispatchingHandler(logging.Handler):
+    """
+    Routes records to a per-channel handler (file/stream), based on LogRecord.log_channel
+    which is set by ChannelFilter.
+    """
+    def __init__(self):
+        super().__init__()
+        self._channel_handlers: Dict[str, logging.Handler] = {}
+        self._enabled: Dict[str, bool] = {}
+        self._default_channel = "default"
+
+    def set_default_channel(self, name: str) -> None:
+        self._default_channel = name
+
+    def add_channel(self, name: str, handler: logging.Handler, enabled: bool = True) -> None:
+        self._channel_handlers[name] = handler
+        self._enabled[name] = enabled
+
+    def enable(self, name: str) -> None:
+        self._enabled[name] = True
+
+    def disable(self, name: str) -> None:
+        self._enabled[name] = False
+
+    def remove_channel(self, name: str) -> None:
+        h = self._channel_handlers.pop(name, None)
+        self._enabled.pop(name, None)
+        if h:
+            try:
+                h.flush()
+                h.close()
+            except Exception:
+                pass
+
+    def has_channel(self, name: str) -> bool:
+        return name in self._channel_handlers
+
+    def emit(self, record: logging.LogRecord) -> None:
+        channel = getattr(record, "log_channel", None) or self._default_channel
+        handler = self._channel_handlers.get(channel) or self._channel_handlers.get(self._default_channel)
+        if not handler:
+            return  # nothing to write to
+        if not self._enabled.get(channel, True):
+            return  # channel muted
+        handler.emit(record)
+
+@dataclass
+class ChannelConfig:
+    name: str
+    path: Optional[str] = None
+    level: int = logging.INFO
+    fmt: str = "[%(asctime)s] %(levelname)s %(log_channel)s %(name)s: %(message)s"
+    datefmt: str = "%Y-%m-%d %H:%M:%S"
+    rotation: Optional[str] = None
+    # rotation options:
+    #   None                     -> plain FileHandler
+    #   "size:10MB:3"            -> RotatingFileHandler(maxBytes=10MB, backupCount=3)
+    #   "time:midnight:7"        -> TimedRotatingFileHandler(when="midnight", backupCount=7)
+
+class LoggingHub:
+    """
+    A centralized, context-aware logging hub.
+    Usage:
+        hub = LoggingHub()
+        hub.init_root()  # do once at startup
+        hub.start_channel(ChannelConfig(name="default", path="logs/default.log"))
+        hub.set_current("default")
+
+        # In any module:
+        log = logging.getLogger("gedcomx")
+        log.info("hello")  # goes to current channel
+
+        with hub.use("import-job-42"):
+            log.info("within job 42")
+    """
+    def __init__(self, root_logger_name: str = "gedcomx"):
+        self.root_name = root_logger_name
+        self._root = logging.getLogger(self.root_name)
+        self._dispatch = DispatchingHandler()
+        self._root.setLevel(logging.DEBUG)  # Let handlers control final level
+
+        self._filter = ChannelFilter()
+        self._initialized = False
+
+    # -------- Initialization --------
+    def init_root(self) -> None:
+        if self._initialized:
+            return
+        # Clean existing handlers on the root logger (optional safety)
+        for h in list(self._root.handlers):
+            self._root.removeHandler(h)
+        self._root.addFilter(self._filter)
+        self._root.addHandler(self._dispatch)
+        self._initialized = True
+
+    # -------- Channel Management --------
+    def start_channel(self, cfg: ChannelConfig, make_current: bool = False, enabled: bool = True) -> None:
+        """Create/replace a channel with a file/rotating handler."""
+        handler: logging.Handler
+        formatter = logging.Formatter(cfg.fmt, datefmt=cfg.datefmt)
+
+        if cfg.path is None:
+            # StreamHandler to stdout if no path provided
+            handler = logging.StreamHandler()
+        else:
+            # Rotation options
+            if cfg.rotation and cfg.rotation.startswith("size:"):
+                # "size:10MB:3"
+                _, size_str, backups_str = cfg.rotation.split(":")
+                size_str = size_str.upper().replace("MB", "*1024*1024").replace("KB", "*1024")
+                max_bytes = int(eval(size_str))  # safe for the limited substitutions we made
+                backup_count = int(backups_str)
+                handler = RotatingFileHandler(cfg.path, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8")
+            elif cfg.rotation and cfg.rotation.startswith("time:"):
+                # "time:midnight:7" or "time:H:24"
+                parts = cfg.rotation.split(":")
+                when = parts[1]
+                backup_count = int(parts[2]) if len(parts) > 2 else 7
+                handler = TimedRotatingFileHandler(cfg.path, when=when, backupCount=backup_count, encoding="utf-8", utc=False)
+            else:
+                handler = logging.FileHandler(cfg.path, encoding="utf-8")
+
+        handler.setLevel(cfg.level)
+        handler.setFormatter(formatter)
+
+        # Replace if exists
+        if self._dispatch.has_channel(cfg.name):
+            self._dispatch.remove_channel(cfg.name)
+        self._dispatch.add_channel(cfg.name, handler, enabled=enabled)
+
+        if make_current:
+            self.set_current(cfg.name)
+
+    def stop_channel(self, name: str) -> None:
+        self._dispatch.remove_channel(name)
+
+    def enable(self, name: str) -> None:
+        self._dispatch.enable(name)
+
+    def disable(self, name: str) -> None:
+        self._dispatch.disable(name)
+
+    def list_channels(self) -> Dict[str, bool]:
+        """Return dict of channel -> enabled?"""
+        return {name: enabled for name, enabled in self._dispatch._enabled.items()}
+
+    # -------- Current Channel --------
+    def set_current(self, name: str) -> None:
+        set_current_channel(name)
+
+    @contextmanager
+    def use(self, name: str):
+        """Temporarily switch to a channel within a with-block."""
+        token = _current_channel.set(name)
+        try:
+            yield
+        finally:
+            _current_channel.reset(token)
+
+    # -------- Utilities --------
+    def set_default_channel(self, name: str) -> None:
+        self._dispatch.set_default_channel(name)

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/gedcomx/__init__.py

@@ -7,6 +7,7 @@ from .Date import Date
 from .Document import Document
 from .Document import DocumentType
 from .EvidenceReference import EvidenceReference
+from .ExtensibleEnum import ExtensibleEnum
 from .Event import Event
 from .Event import EventType
 from .Event import EventRole

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gedcom-x"
-version = "0.5.5"
+version = "0.5.6"
 description = "Python implimentation of gedcom-x standard"
 readme = "README.md"
 requires-python = ">=3.8"

{gedcom_x-0.5.5 → gedcom_x-0.5.6}/setup.py

@@ -1,14 +1,20 @@
 # setup.py
 from setuptools import setup, find_packages
 
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
 setup(
     name='gedcom-x',
-    version='0.5.5',
+    version='0.5.6',
     packages=find_packages(),
-    install_requires=[
+    description="A Python toolkit for working with GEDCOM-X",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    #install_requires=[
         # List your project dependencies here, e.g.,
-        'ged4py',
-    ],
+    #    None,
+    #],
     entry_points={
         'console_scripts': [
             # Define command-line scripts if needed

gedcom_x-0.5.5/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: gedcom-x
-Version: 0.5.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.5/gedcom_x.egg-info/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: gedcom-x
-Version: 0.5.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