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

gedcomx/{Gedcom5x.py → gedcom5x.py}

@@ -3,14 +3,26 @@
 
 import html
 import os
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Any
 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()
+import logging
+from .logging_hub import hub, ChannelConfig
+
+job_id = "gedcomx.parsing.GEDCOM5x"
+
+hub.start_channel(
+    ChannelConfig(
+        name=job_id,
+        path=f"logs/{job_id}.log",
+        level=logging.DEBUG,
+        rotation="size:10MB:3",   # rotate by size, keep 3 backups
+    )
+)
+
+log = logging.getLogger("gedcomx")
 
 BOM = '\ufeff'
 
@@ -51,25 +63,25 @@ line = f'{level}{d}((?P<xref>{xref}){d})?(?P<tag>{tag})({d}{lineval})?{eol}'
 from typing import List, Optional, Iterator, Union
 
 
-class GedcomRecord():
+class Gedcom5xRecord():
     def __init__(
         self,
         line_num: Optional[int] = None,
         level: int = -1,
-        tag: str = "NONR",
+        tag: str | None = "NONR",
         xref: Optional[str] = None,
         value: Optional[str] = None,
     ) -> None:
         self.line = line_num
-        self._subRecords: List[GedcomRecord] = []
+        self._subRecords: List[Gedcom5xRecord] = []
         self.level = int(level)
         self.xref = xref
         self.pointer: bool = False
         self.tag = str(tag).strip()
         self.value = value
 
-        self.parent: Optional[GedcomRecord] = None
-        self.root: Optional[GedcomRecord] = None
+        self.parent: Optional[Gedcom5xRecord] = None
+        self.root: Optional[Gedcom5xRecord] = None
 
     # ───────────────────────────────
     # Dict/JSON friendly view
@@ -88,7 +100,7 @@ class GedcomRecord():
     # ───────────────────────────────
     # Subrecord management
     # ───────────────────────────────
-    def addSubRecord(self, record: "GedcomRecord"):
+    def addSubRecord(self, record: "Gedcom5xRecord"):
        
         if record is not None and (record.level == (self.level + 1)):
             record.parent = self
@@ -99,7 +111,7 @@ class GedcomRecord():
             )
 
     def recordOnly(self):
-        return GedcomRecord(
+        return Gedcom5xRecord(
             line_num=self.line, level=self.level, tag=self.tag, value=self.value
         )
 
@@ -123,7 +135,7 @@ class GedcomRecord():
             f"subRecords: {len(self._subRecords)}"
         )
         if subRecords:
-            for subRecord in self.subRecords():
+            for subRecord in self.subRecords() or []:
                 description += "\n" + subRecord.describe(subRecords=True)
         return description
 
@@ -132,9 +144,9 @@ class GedcomRecord():
     # ───────────────────────────────
     def subRecord(self, tag: str):
         result = [r for r in self._subRecords if r.tag == tag]
-        return None if not result else result
+        return [] if not result else result
 
-    def subRecords(self, tag: str = None):
+    def subRecords(self, tag: str | None = None) -> List['Gedcom5xRecord']:
         if not tag:
             return self._subRecords
         tags = tag.split("/", 1)
@@ -142,7 +154,7 @@ class GedcomRecord():
         # Collect matching first-level subrecords
         matches = [r for r in self._subRecords if r.tag == tags[0]]
         if not matches:
-            return None
+            return []
 
         if len(tags) == 1:
             return matches
@@ -156,7 +168,7 @@ class GedcomRecord():
                     results.extend(sub_result)
                 else:
                     results.append(sub_result)
-        return results if results else None
+        return results if results else []
 
     # ───────────────────────────────
     # Iteration / Subscriptability
@@ -164,11 +176,11 @@ class GedcomRecord():
     def __call__(self) -> str:
         return self.describe()
 
-    def __iter__(self) -> Iterator["GedcomRecord"]:
+    def __iter__(self) -> Iterator["Gedcom5xRecord"]:
         """Iterates recursively over self and all subrecords."""
         yield from self._flatten_subrecords(self)
 
-    def _flatten_subrecords(self, record: "GedcomRecord") -> Iterator["GedcomRecord"]:
+    def _flatten_subrecords(self, record: "Gedcom5xRecord") -> Iterator["Gedcom5xRecord"]:
         yield record
         for sub in record._subRecords:
             yield from self._flatten_subrecords(sub)
@@ -176,7 +188,7 @@ class GedcomRecord():
     def __len__(self) -> int:
         return len(self._subRecords)
 
-    def __getitem__(self, key: Union[int, slice, str]) -> Union["GedcomRecord", List["GedcomRecord"]]:
+    def __getitem__(self, key: Union[int, slice, str]) -> Union["Gedcom5xRecord", List["Gedcom5xRecord"]]:
         """
         - rec[0] -> first subrecord
         - rec[1:3] -> slice of subrecords
@@ -222,26 +234,26 @@ 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:
+    def __init__(self, records: Optional[List[Gedcom5xRecord]] = None,filepath: str | None = None) -> None:
 
-        self.records: List[GedcomRecord] = records or []
+        self.records: List[Gedcom5xRecord] = records or []
         if filepath:
             self.records = self._records_from_file(filepath)
         elif records:
-            self.records: List[GedcomRecord] = records if records else []
+            self.records: List[Gedcom5xRecord] = records if records else []
         
         
         # Fast tag index: {'HEAD': [rec], 'INDI': [rec1, rec2, ...], ...}
-        self._tag_index: dict[str, List[GedcomRecord]] = defaultdict(list)
+        self._tag_index: dict[str, List[Gedcom5xRecord]] = defaultdict(list)
         self._reindex()
         
-        self.header: GedcomRecord | None = None
-        self._sources: List[GedcomRecord] = []
-        self._repositories: List[GedcomRecord] = []
-        self._individuals: List[GedcomRecord] = []
-        self._families: List[GedcomRecord] = []
-        self._objects: List[GedcomRecord] = []
-        self._snotes: List[GedcomRecord] = []
+        self.header: Gedcom5xRecord | None = None
+        self._sources: List[Gedcom5xRecord] = []
+        self._repositories: List[Gedcom5xRecord] = []
+        self._individuals: List[Gedcom5xRecord] = []
+        self._families: List[Gedcom5xRecord] = []
+        self._objects: List[Gedcom5xRecord] = []
+        self._snotes: List[Gedcom5xRecord] = []
         self.version = None
 
         if self.records:
@@ -277,7 +289,7 @@ class Gedcom5x():
     def __len__(self) -> int:
         return len(self.records)
 
-    def __iter__(self) -> Iterator['GedcomRecord']:
+    def __iter__(self) -> Iterator['Gedcom5xRecord']:
         # Enables: for x in gedcom:
         return iter(self.records)
 
@@ -289,7 +301,7 @@ class Gedcom5x():
             return 0 <= key < len(self.records)
         return False
 
-    def __getitem__(self, key: Key) -> Union['GedcomRecord', List['GedcomRecord']]:
+    def __getitem__(self, key: Key) -> Union['Gedcom5xRecord', List['Gedcom5xRecord']]:
         """
         - gedcom[0] -> GedcomRecord at index 0
         - gedcom[1:5] -> list of GedcomRecord (slice)
@@ -309,30 +321,30 @@ class Gedcom5x():
         raise TypeError(f"Unsupported key type: {type(key).__name__}")
 
     # Optional: convenience helpers
-    def by_tag(self, tag: str) -> List['GedcomRecord']:
+    def by_tag(self, tag: str) -> List['Gedcom5xRecord']:
         """Always return a list of records for a tag (empty list if none)."""
         return list(self._tag_index.get(tag, []))
 
-    def first(self, tag: str) -> Optional['GedcomRecord']:
+    def first(self, tag: str) -> Optional['Gedcom5xRecord']:
         """Return the first record with a given tag, or None."""
         lst = self._tag_index.get(tag, [])
         return lst[0] if lst else None
 
     # If you add/replace records after init, keep the index fresh:
-    def append(self, rec: 'GedcomRecord') -> None:
+    def append(self, rec: 'Gedcom5xRecord') -> None:
         self.records.append(rec)
         self._tag_index.setdefault(rec.tag, []).append(rec)
 
-    def extend(self, recs: Iterable['GedcomRecord']) -> None:
+    def extend(self, recs: Iterable['Gedcom5xRecord']) -> None:
         self.records.extend(recs)
         for r in recs:
             self._tag_index.setdefault(r.tag, []).append(r)
 
-    def insert(self, idx: int, rec: 'GedcomRecord') -> None:
+    def insert(self, idx: int, rec: 'Gedcom5xRecord') -> None:
         self.records.insert(idx, rec)
         self._tag_index.setdefault(rec.tag, []).append(rec)
 
-    def remove(self, rec: 'GedcomRecord') -> None:
+    def remove(self, rec: 'Gedcom5xRecord') -> None:
         self.records.remove(rec)
         try:
             bucket = self._tag_index.get(rec.tag)
@@ -385,55 +397,55 @@ class Gedcom5x():
         print_table(imports_stats)
 
     @property
-    def sources(self) -> List[GedcomRecord]:
+    def sources(self) -> List[Gedcom5xRecord]:
         return self._sources
 
     @sources.setter
-    def sources(self, value: List[GedcomRecord]):
-        if not isinstance(value, list) or not all(isinstance(item, GedcomRecord) for item in value):
+    def sources(self, value: List[Gedcom5xRecord]):
+        if not isinstance(value, list) or not all(isinstance(item, Gedcom5xRecord) for item in value):
             raise ValueError("sources must be a list of GedcomRecord objects.")
         self._sources = value
 
     @property
-    def repositories(self) -> List[GedcomRecord]:
+    def repositories(self) -> List[Gedcom5xRecord]:
         """
         List of **REPO** records found in the Genealogy
         """
         return self._repositories
 
     @repositories.setter
-    def repositories(self, value: List[GedcomRecord]):
-        if not isinstance(value, list) or not all(isinstance(item, GedcomRecord) for item in value):
+    def repositories(self, value: List[Gedcom5xRecord]):
+        if not isinstance(value, list) or not all(isinstance(item, Gedcom5xRecord) for item in value):
             raise ValueError("repositories must be a list of GedcomRecord objects.")
         self._repositories = value
 
     @property
-    def individuals(self) -> List[GedcomRecord]:
+    def individuals(self) -> List[Gedcom5xRecord]:
         return self._individuals
 
     @individuals.setter
-    def individuals(self, value: List[GedcomRecord]):
-        if not isinstance(value, list) or not all(isinstance(item, GedcomRecord) for item in value):
+    def individuals(self, value: List[Gedcom5xRecord]):
+        if not isinstance(value, list) or not all(isinstance(item, Gedcom5xRecord) for item in value):
             raise ValueError("individuals must be a list of GedcomRecord objects.")
         self._individuals = value
 
     @property
-    def families(self) -> List[GedcomRecord]:
+    def families(self) -> List[Gedcom5xRecord]:
         return self._families
 
     @families.setter
-    def families(self, value: List[GedcomRecord]):
-        if not isinstance(value, list) or not all(isinstance(item, GedcomRecord) for item in value):
+    def families(self, value: List[Gedcom5xRecord]):
+        if not isinstance(value, list) or not all(isinstance(item, Gedcom5xRecord) for item in value):
             raise ValueError("families must be a list of GedcomRecord objects.")
         self._families = value
 
     @property
-    def objects(self) -> List[GedcomRecord]:
+    def objects(self) -> List[Gedcom5xRecord]:
         return self._objects
 
     @objects.setter
-    def objects(self, value: List[GedcomRecord]):
-        if not isinstance(value, list) or not all(isinstance(item, GedcomRecord) for item in value):
+    def objects(self, value: List[Gedcom5xRecord]):
+        if not isinstance(value, list) or not all(isinstance(item, Gedcom5xRecord) for item in value):
             raise ValueError("objects must be a list of GedcomRecord objects.")
         self._objects = value
 
@@ -449,7 +461,7 @@ class Gedcom5x():
         raise NotImplementedError("Writing of GEDCOM files is not implemented.")  
 
     @staticmethod
-    def _records_from_file(file_path: str) -> List[GedcomRecord]:
+    def _records_from_file(file_path: str) -> List[Gedcom5xRecord]:
         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@)
@@ -483,7 +495,7 @@ class Gedcom5x():
             lines = [line.strip() for line in file]
 
             records = []
-            record_map = {0: None, 1: None, 2: None, 3: None, 4: None, 5: None}
+            record_map: dict[int,Any] = {0: None, 1: None, 2: None, 3: None, 4: None, 5: None}
             
             for l, line in enumerate(lines):
                 if line.startswith(BOM):
@@ -510,15 +522,18 @@ class Gedcom5x():
                 else:
                     level, tag = parts
 
-                level, xref, tag, value, xref_value = parse_gedcom7_line(line)
+                level, xref, tag, value, xref_value = parse_gedcom7_line(line) or tuple([None, None, None, None])
+                
                 
                 if xref is None and xref_value is not None:
                     xref = xref_value
                # print(l, level, xref, tag, value, xref_value)
-                    
-                level = int(level)
 
-                new_record = GedcomRecord(line_num=l + 1, level=level, tag=tag, xref=xref,value=value)
+                if isinstance(level,int):    
+                    level = int(level)
+                else: raise ValueError(f"Record had a level of {level}") 
+
+                new_record = Gedcom5xRecord(line_num=l + 1, level=level, tag=tag if tag else None, xref=xref,value=value)
                 
                 
                 if level == 0:
@@ -528,12 +543,14 @@ class Gedcom5x():
                     new_record.parent = record_map[int(level) - 1]
                     record_map[int(level) - 1].addSubRecord(new_record)
                 record_map[int(level)] = new_record
+                with hub.use(job_id):
+                    log.info(new_record.describe())
         
         
-        return records if records else None
+        return records if records else []
 
     @staticmethod
-    def fromFile(file_path: str) -> 'Gedcom':
+    def fromFile(file_path: str) -> 'Gedcom5x':
         """
         Static method to create a Gedcom object from a GEDCOM file.
 

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]
+
+    
+    
+