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

gedcomx/{Fact.py → fact.py}

@@ -1,28 +1,38 @@
 import difflib
 import re
 
-from datetime import datetime
 from enum import Enum
 from typing import List, Optional, Dict, Any
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    fact.py
+ Author:  David J. Cartwright
+ Purpose: 
 
-from .Attribution import Attribution
-from .Conclusion import ConfidenceLevel
-from .Document import Document
-from .Date import Date
-from .Note import Note
-from .PlaceReference import PlaceReference
-from .SourceReference import SourceReference
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: 
+   
+======================================================================
+"""
 
-from .Resource import Resource
-
-from .Conclusion import Conclusion
-from .Qualifier import Qualifier
-
-from enum import Enum
-
-from collections.abc import Sized
-
-from .Extensions.rs10.rsLink import rsLink, _rsLinkList
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .attribution import Attribution
+from .conclusion import Conclusion, ConfidenceLevel
+from .date import Date
+from .document import Document
+from .Extensions.rs10.rsLink import _rsLinkList
+from .note import Note
+from .place_reference import PlaceReference
+from .qualifier import Qualifier
+from .resource import Resource
+from .source_reference import SourceReference
+#=====================================================================
 
 
 class FactType(Enum):
@@ -370,7 +380,6 @@ class FactType(Enum):
                 return keywords_to_fact_type[matches[0]]
         return None
 
-
 class FactQualifier(Enum):
     Age = "http://gedcomx.org/Age"
     Cause = "http://gedcomx.org/Cause"
@@ -389,7 +398,6 @@ class FactQualifier(Enum):
         }
         return descriptions.get(self, "No description available.")
 
-
 class Fact(Conclusion):
     identifier = 'http://gedcomx.org/v1/Fact'
     version = 'http://gedcomx.org/conceptual-model/v1'
@@ -397,9 +405,9 @@ class Fact(Conclusion):
     def __init__(self,
                  id: Optional[str] = None,
                  lang: Optional[str] = None,
-                 sources: Optional[List[SourceReference]] = [],
+                 sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource | Document] = None,
-                 notes: Optional[List[Note]] = [],
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  type: Optional[FactType] = None,
@@ -428,7 +436,7 @@ class Fact(Conclusion):
 
     @property
     def _as_dict_(self):
-        from .Serialization import Serialization
+        from .serialization import Serialization
         type_as_dcit = super()._as_dict_
         # Only add Relationship-specific fields
         if self.type:

gedcomx/{Gedcom5x.py → gedcom5x.py}

@@ -9,7 +9,7 @@ from collections import defaultdict
 from typing import Iterable, Iterator, List, Optional, Tuple, Union
 
 import logging
-from .LoggingHub import hub, ChannelConfig
+from .logging_hub import hub, ChannelConfig
 
 job_id = "gedcomx.parsing.GEDCOM5x"
 

gedcomx/gedcom7/Exceptions.py

@@ -0,0 +1,9 @@
+
+
+
+class GedcomError(Exception):
+    """Generic error in GEDCOM processing."""
+    pass
+
+class GedcomInvalidSubStructure(Exception):
+    pass

gedcomx/gedcom7/Gedcom7.py

@@ -0,0 +1,160 @@
+
+from __future__ import annotations
+from typing import Any, Dict, List, Optional, Union, Iterable
+from collections import defaultdict
+
+
+from .GedcomStructure import GedcomStructure
+from . import Specification as g7specs
+from .logger import get_logger
+
+
+from typing import Dict, List, Optional
+
+
+
+class Gedcom7:
+    def __init__(self, filepath: Optional[str] = None):
+        self.persons: List[Any] = []
+        self.families: List[Any] = []
+        self.sources: List[Any] = []
+        self.records: List['GedcomStructure'] = []
+        self._tag_index: Dict[str, List[int]] = defaultdict(list)  # tag -> list of record indices
+
+    # ---- indexing helpers -------------------------------------------------
+    @staticmethod
+    def _norm_tag(tag: str) -> str:
+        return tag.upper()
+
+    def _rebuild_index(self) -> None:
+        self._tag_index.clear()
+        for i, rec in enumerate(self.records):
+            if getattr(rec, "tag", None):
+                self._tag_index[self._norm_tag(rec.tag)].append(i)
+
+    # Optional: keep index in sync if you append records elsewhere
+    def _append_record(self, rec: 'GedcomStructure') -> None:
+        self.records.append(rec)
+        if getattr(rec, "tag", None):
+            self._tag_index[self._norm_tag(rec.tag)].append(len(self.records) - 1)
+
+    # ---- Python container protocol ----------------------------------------
+    def __len__(self) -> int:
+        return len(self.records)
+
+    def __iter__(self) -> Iterable['GedcomStructure']:
+        return iter(self.records)
+
+    def __contains__(self, key: Union[str, 'GedcomStructure']) -> bool:
+        if isinstance(key, str):
+            return self._norm_tag(key) in self._tag_index
+        return key in self.records
+
+    def __getitem__(self, key: Union[int, slice, str, tuple]) -> Union['GedcomStructure', List['GedcomStructure']]:
+        # by position
+        if isinstance(key, (int, slice)):
+            return self.records[key]
+
+        # by tag
+        if isinstance(key, str):
+            idxs = self._tag_index.get(self._norm_tag(key), [])
+            return [self.records[i] for i in idxs]
+
+        # combo: ('INDI', 0) or ('INDI', 0:5)
+        if isinstance(key, tuple) and len(key) == 2 and isinstance(key[0], str):
+            tag, sub = key
+            items = self[tag]  # list for that tag
+            if isinstance(sub, int) or isinstance(sub, slice):
+                return items[sub]
+            raise TypeError(f"Unsupported sub-key type: {type(sub)!r}")
+
+        raise TypeError(f"Unsupported key type: {type(key)!r}")
+
+    # ---- your existing methods (trimmed) ----------------------------------
+    @staticmethod   
+    def parse_gedcom_line(line: str) -> Optional[Dict[str, Any]]:
+                
+        line = line.lstrip('\ufeff').rstrip('\r\n')
+        if not line:
+            return None
+
+        parts = line.split(maxsplit=3)
+        if len(parts) < 2:
+            return None  # not even "0 HEAD"
+
+        # 1) Level
+        try:
+            level = int(parts[0])
+        except ValueError:
+            return None
+
+        # 2) Is parts[1] an XREF?
+        xref = None
+        if parts[1].startswith('@') and parts[1].endswith('@'):
+            xref = parts[1]
+
+        # 3) Where is the tag?
+        if xref:
+            # must have at least ["0", "@X@", "TAG"]
+            if len(parts) < 3:
+                return None
+            tag = parts[2]
+            # everything after index 2 is the value
+            value_parts = parts[3:]  # could be empty or one-element
+        else:
+            tag = parts[1]
+            # everything after index 1 is the value
+            value_parts = parts[2:]  # could be empty, one- or two-element
+            
+
+        # 4) re-assemble the full value
+        value = " ".join(value_parts)  # empty string if value_parts == []
+        if value.startswith('@') and value.endswith('@'):
+            xref = parts[1]
+
+        if tag == 'TAG':
+            xtag, uri = value.split()
+            g7specs.structure_specs[xtag] = uri
+            g7specs.structure_specs[uri] = {'label': 'Extension_' + xtag}
+            
+        return {
+            "level": level,
+            "xref": xref,
+            "tag": tag,
+            "value": value
+        }
+
+
+    def loadfile(self, filepath: str) -> None:
+        log = get_logger('importlog')
+        context: Dict[int, GedcomStructure] = {}
+        records: List[GedcomStructure] = []
+
+        with open(filepath, 'r', encoding='utf8') as file:
+            for lineno, raw in enumerate(file, start=1):
+                record = Gedcom7.parse_gedcom_line(raw)
+                if record is None:
+                    log.error(f'empty line at {lineno}: {raw}')
+                    continue
+
+                level = int(record["level"])
+                if record["tag"] == g7specs.CONT:
+                    context[level - 1].value += "\n" + record["value"]
+                    continue
+
+                structure = GedcomStructure(
+                    level=level,
+                    tag=record["tag"],
+                    xref=record["xref"],
+                    text=record["value"],
+                    parent=context[level - 1] if level > 0 else None,
+                    line_num=lineno
+                )
+
+                if level == 0:
+                    records.append(structure)
+
+                context[level] = structure
+
+        self.records = records
+        self._rebuild_index()  # <-- build fast tag index once

gedcomx/gedcom7/GedcomStructure.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Dict, Any
+import warnings
+from . import Specification as g7
+
+from typing import Dict, List,Optional,Any
+
+
+gedcom_top_level_terms = ['https://gedcom.io/terms/v7/CONT',
+                          'https://gedcom.io/terms/v7/record-FAM',
+                          'https://gedcom.io/terms/v7/record-INDI',
+                          'https://gedcom.io/terms/v7/record-SNOTE',
+                          'https://gedcom.io/terms/v7/record-SUBM',
+                          'https://gedcom.io/terms/v7/TRLR',
+                          'https://gedcom.io/terms/v7/HEAD',
+                          'https://gedcom.io/terms/v7/record-OBJE',
+                          'https://gedcom.io/terms/v7/record-REPO',
+                          'https://gedcom.io/terms/v7/record-SOUR']
+
+
+
+
+class GedcomStructure:
+    version = 'v7'
+
+    def __init__(
+        self,
+        *,
+        level: int | None = None,
+        xref: str | None = None,
+        tag: str | None = None,
+        pointer: bool | None = None,
+        text: str | None = None,
+        parent: GedcomStructure | None = None,
+        line_num: int | None = None
+    ) -> None:
+        """Create a GEDCOM structure node.
+
+        Args:
+            level: GEDCOM line level (0..n).
+            xref: Optional cross-reference id (e.g., '@I1@').
+            tag: GEDCOM tag (e.g., 'INDI', 'NAME').
+            pointer: True if this line is a pointer, False if not, None if unknown.
+            text: Literal text payload for this line.
+            parent: Parent node in the structure tree, if any.
+        """
+        self.level = level
+        self.xref = xref
+        self.tag = tag
+        self.pointer = pointer
+        self.text = text
+        self.parent = parent
+        self.value = text
+        self.pointer = pointer if pointer else False
+        self.line_num = line_num
+        
+        if self.level and self.level > 0 and text and text.startswith('@') and text.endswith('@'):
+            self.pointer = True
+            self.xref = text
+        
+        self.parent: GedcomStructure | None = parent if parent else None
+        if self.parent and isinstance(self.parent, GedcomStructure):
+            parent.subtructures.append(self)
+
+        self.extension = False if not tag else True if tag.startswith('_') else False 
+        self.uri = g7.match_uri(tag,self.parent) 
+        self.label = g7.get_label(self.uri)
+        
+        self.subtructures = []
+        
+
+    def _as_dict_(self):
+        as_dict =  {}
+        as_dict['level'] = self.level
+        if self.xref: as_dict['xref'] = self.xref
+        as_dict['tag'] = self.tag
+        if self.value: as_dict['value'] = self.value
+        if self.subtructures: as_dict['substructures'] = [substructure._as_dict_() for substructure in self.subtructures]
+        return {g7.get_label(self.uri):as_dict}
+       
+    def __repr__(self):
+        return (
+            "GedcomStructure("
+            f"level: {self.level} tag={self.tag:<6} ({self.label}), {'(Ext)' if self.extension else ''} xref:{self.xref}  pointer={self.pointer}, text='{self.value}',  "
+            f"uri={self.uri} subStructures: {len(self.subtructures)}"
+        )
+    
+    def __getitem__(self,index) -> List['GedcomStructure']:
+        return [s for s in self.subtructures if s.tag == index]
+
+    
+    
+