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

gedcomx/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 .LoggingHub 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.