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

gedcomx/Gedcom5x.py

@@ -3,11 +3,27 @@
 
 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
 
+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'
 
 GEDCOM7_LINE_RE = re.compile(
@@ -47,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
@@ -84,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
@@ -95,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
         )
 
@@ -119,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
 
@@ -128,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)
@@ -138,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
@@ -152,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
@@ -160,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)
@@ -172,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
@@ -218,23 +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[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:
@@ -270,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)
 
@@ -282,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)
@@ -302,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)
@@ -356,7 +375,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)
@@ -378,60 +397,58 @@ 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
 
-    
-
     def write(self) -> bool:
         """
         Method placeholder for writing GEDCOM files.
@@ -444,7 +461,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[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@)
@@ -466,19 +483,19 @@ 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 = []
-            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):
@@ -505,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:
@@ -523,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(filepath: str) -> 'Gedcom':
+    def fromFile(file_path: str) -> 'Gedcom5x':
         """
         Static method to create a Gedcom object from a GEDCOM file.
 
@@ -538,21 +560,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