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

gedcomx/converter.py

@@ -3,6 +3,11 @@ import logging
 import mimetypes
 import re
 import xml.etree.ElementTree as ET
+
+from typing import Any, Mapping
+import math
+import shutil
+
 """
 ======================================================================
  Project: Gedcom-X
@@ -22,8 +27,7 @@ import xml.etree.ElementTree as ET
 GEDCOM Module Types
 ======================================================================
 """
-from typing import List, Optional, Any
-from xml.dom import minidom
+
 from .address import Address
 from .agent import Agent
 from .attribution import Attribution
@@ -41,7 +45,6 @@ from .gedcomx import GedcomX
 from .gender import Gender, GenderType
 from .group import Group
 from .identifier import Identifier, IdentifierType, make_uid, IdentifierList
-from .Logging import get_logger
 from .logging_hub import hub, ChannelConfig
 from .name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
 from .note import Note
@@ -59,9 +62,25 @@ from .source_reference import SourceReference, KnownSourceReference
 from .textvalue import TextValue
 #from .topleveltypecollection import TopLevelTypeCollection
 from .uri import URI
-
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
 log = logging.getLogger("gedcomx")
-job_id = "gedcomx.convert.GEDCOM5x"
+serial_log = "gedcomx.serialization"
+convert_log = "gedcomx.convert.GEDCOM5x"
+#=====================================================================
+
+hub.start_channel(
+    ChannelConfig(
+        name=convert_log,
+        path=f"logs/{convert_log}.log",
+        level=logging.DEBUG,
+        rotation="size:10MB:3",   # rotate by size, keep 3 backups
+    ))
+
 
 class GedcomConverter():
     def __init__(self) -> None:
@@ -69,6 +88,9 @@ class GedcomConverter():
         self.object_map: dict[Any, Any] = {-1:self.gedcomx}
         self.missing_handler_count = {}
     
+    type_name_type = {
+        'aka': NameType.AlsoKnownAs
+    }
     gedcom_even_to_fact = {
     # Person Fact Types
     "ADOP": FactType.Adoption,
@@ -157,6 +179,9 @@ class GedcomConverter():
     
 }
     
+    @property
+    def ignored_tags(self):
+        return self.missing_handler_count if self.missing_handler_count != {} else None
 
     def clean_str(self, text: str | None) -> str:
         # Regular expression to match HTML/XML tags
@@ -166,15 +191,19 @@ class GedcomConverter():
         
         return clean_text
     
-    def parse_gedcom5x_recrod(self,record: Gedcom5xRecord):
-        if record: 
-            with hub.use(job_id):       
+    def parse_gedcom5x_record(self,record: Gedcom5xRecord):
+        if record is not None: 
+            with hub.use(convert_log):       
                 handler_name = 'handle_' + record.tag.lower()
                 
                 if hasattr(self,handler_name): 
-                    log.info(f'Parsing Record: {record.describe()}')         
+                    log.info(f'Using {handler_name} to pars Record: {record.describe()}')         
                     handler = getattr(self,handler_name)            
                     handler(record)
+                    if record.tag != 'FAM':
+                        for sub_record in record.subRecords():
+                            log.debug(sub_record.describe())
+                            self.parse_gedcom5x_record(sub_record)
                 else:
                     if record.tag in self.missing_handler_count:
                         self.missing_handler_count[record.tag] += 1
@@ -182,14 +211,16 @@ class GedcomConverter():
                         self.missing_handler_count[record.tag] = 1
                     
                     log.error(f'Failed Parsing Record: {record.describe()}')
-                for sub_record in record.subRecords():
-                    self.parse_gedcom5x_recrod(sub_record)
+                log.debug(f"{record.tag} with id: {record.xref} has {len(record.subRecords())} subRecords")
+                
+        else:
+            assert False
     
     def handle__apid(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].description.add_identifier(Identifier(value=[URI.from_url('APID://' + record.value if record.value else '')]))
+            self.object_map[record.level-1].description.add_identifier(Identifier(type=IdentifierType.Other, value=[URI.from_url('APID://' + record.value if record.value else '')]))
         elif isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].add_identifier(Identifier(value=[URI.from_url('APID://' + record.value if record.value else '')]))
+            self.object_map[record.level-1].add_identifier(Identifier(type=IdentifierType.Other,value=[URI.from_url('APID://' + record.value if record.value else '')]))
         else:
             raise ValueError(f"Could not handle '_APID' tag in record {record.describe()}, last stack object {type(self.object_map[record.level-1])}")
 
@@ -337,9 +368,9 @@ class GedcomConverter():
 
     def handle_caln(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].description.add_identifier(Identifier(value=[URI.from_url('Call Number:' + record.value if record.value else '')]))
+            self.object_map[record.level-1].description.add_identifier(Identifier(type=IdentifierType.Other,value=[URI.from_url('Call Number:' + record.value if record.value else '')]))
         elif isinstance(self.object_map[record.level-1], SourceDescription):
-            self.object_map[record.level-1].add_identifier(Identifier(value=[URI.from_url('Call Number:' + record.value if record.value else '')]))
+            self.object_map[record.level-1].add_identifier(Identifier(type=IdentifierType.Other,value=[URI.from_url('Call Number:' + record.value if record.value else '')]))
         elif isinstance(self.object_map[record.level-1], Agent):
             pass
             # TODO Why is GEDCOM so shitty? A callnumber for a repository?
@@ -523,7 +554,11 @@ class GedcomConverter():
                         
                         self.object_map[record.level] = gxobject
                 else:
-                    raise TagConversionError(record=record,levelstack=self.object_map)
+                    log.warning(f"EVEN type is not known {record.describe()}")
+                    gxobject = Event(roles=[EventRole(person=self.object_map[record.level],type=EventRoleType.Principal)])
+                    self.gedcomx.add_event(gxobject)
+                    self.object_map[record.level] = gxobject
+                    
 
         else:
             possible_fact = FactType.guess(record.subRecord('TYPE')[0].value)
@@ -555,7 +590,7 @@ class GedcomConverter():
 
     def handle_exid(self,record: Gedcom5xRecord):
         if record.value:
-            gxobject = Identifier(type=IdentifierType.External,value=[URI(record.value) if record.value else URI()]) # type: ignore
+            gxobject = Identifier(type=IdentifierType.External,value=[URI._from_json_(record.value) if record.value else URI()]) # type: ignore
             self.object_map[record.level-1].add_identifier(gxobject)       
             self.object_map[record.level] = gxobject
         else: raise ValueError('Record had no value')
@@ -598,7 +633,11 @@ class GedcomConverter():
         if husband and wife:
             relationship = Relationship(person1=husband, person2=wife, type=RelationshipType.Couple)
             self.gedcomx.add_relationship(relationship)
-
+            self.object_map[record.level] = relationship
+        
+        if (marr_record := record.subRecord('MARR')) is not None:
+            self.handle_marr(marr_record[0])
+    
     def handle_famc(self, record: Gedcom5xRecord) -> None:
         return
 
@@ -621,7 +660,7 @@ class GedcomConverter():
                 if mime_type:
                     self.object_map[record.level-2].mediaType = mime_type
                 else:
-                    print(f"Could not determing mime type from {record.value}")
+                    log.error(f"Could not determing mime type from {record.value}")
         elif isinstance(self.object_map[record.level-1], PlaceDescription):
             self.object_map[record.level-1].names.append(TextValue(value=record.value))
         elif record.parent is not None and record.parent.tag == 'TRAN':
@@ -641,10 +680,10 @@ class GedcomConverter():
         if person is None:
             log.warning('Had to create person with id {recrod.xref}')
             if isinstance(record.xref,str):
-                person = Person(id=record.xref.replace('@',''))
+                person = Person(id=record.xref)
+                self.gedcomx.add_person(person)
             else:
-                raise ValueError('INDI Record had no XREF')
-        self.gedcomx.add_person(person) 
+                raise ValueError('INDI Record had no XREF')    
         self.object_map[record.level] = person
 
     def handle_immi(self, record: Gedcom5xRecord):
@@ -658,15 +697,33 @@ class GedcomConverter():
             raise TagConversionError(record=record,levelstack=self.object_map)
 
     def handle_marr(self, record: Gedcom5xRecord):
+        """
         if isinstance(self.object_map[record.level-1], Person):
             gxobject = Fact(type=FactType.Marriage)
             self.object_map[record.level-1].add_fact(gxobject)
 
             
             self.object_map[record.level] = gxobject
+        """
+        if (add_fact := getattr(self.object_map[record.level-1],'add_fact',None)) is not None:
+            gxobject = Fact(type=FactType.Marriage)
+            add_fact(gxobject)
+            self.object_map[record.level] = gxobject       
         else:
             raise TagConversionError(record=record,levelstack=self.object_map)
 
+    def handle__link(self,record: Gedcom5xRecord):
+        if isinstance(self.object_map[record.level-1], SourceReference):
+            gxobject = Identifier([URI.from_url(record.value)],IdentifierType.External)
+            self.object_map[record.level-1].description.add_identifier(gxobject)
+            self.object_map[record.level] = gxobject
+
+    def handle__milt(self, record: Gedcom5xRecord):
+        if isinstance(self.object_map[record.level-1], Person):
+            gxobject = Fact(type=FactType.MilitaryService)
+            self.object_map[record.level-1].add_fact(gxobject)
+            self.object_map[record.level] = gxobject
+
     def handle_name(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], Person):
             gxobject = Name.simple(record.value if record.value else 'WARNING: NAME had no value')
@@ -676,8 +733,10 @@ class GedcomConverter():
             
             self.object_map[record.level] = gxobject
         elif isinstance(self.object_map[record.level-1], Agent):
+            
             gxobject = TextValue(value=record.value)
             self.object_map[record.level-1].add_name(gxobject)
+            
         else:
             raise TagConversionError(record=record,levelstack=self.object_map)
 
@@ -689,11 +748,15 @@ class GedcomConverter():
             
             self.object_map[record.level] = gxobject
         elif isinstance(self.object_map[record.level-1], SourceReference):
-            gxobject = Note(text=self.clean_str(record.value))
-            self.object_map[record.level-1].description.add_note(gxobject)
+            if self.object_map[record.level-1].description is not None:
+                gxobject = Note(text=self.clean_str(record.value))
+                self.object_map[record.level-1].description.add_note(gxobject)
+                self.object_map[record.level] = gxobject
+            else:
+                log.error('SourceReference does not have description')
 
             
-            self.object_map[record.level] = gxobject
+            
         elif isinstance(self.object_map[record.level-1], Conclusion):
             gxobject = Note(text=record.value)
             self.object_map[record.level-1].add_note(gxobject)
@@ -744,12 +807,12 @@ class GedcomConverter():
 
     def handle_page(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], SourceReference):
-            self.object_map[record.level-1].descriptionId = record.value
+            #self.object_map[record.level-1].descriptionId = record.value
             gx_object = KnownSourceReference(name=KnownSourceReference.Page,value=record.value)
             self.object_map[record.level-1].add_qualifier(gx_object)
             self.object_map[record.level] = self.object_map[record.level-1]
         else:
-            raise ValueError(f"Could not handle 'PAGE' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
+            raise ValueError(f"Could not handle 'PAGE' tag in record {record.describe()}, object stack {self.object_map}")
 
     def handle_plac(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], Agent):
@@ -837,9 +900,9 @@ class GedcomConverter():
     def handle_repo(self, record: Gedcom5xRecord):
 
         if record.level == 0:
-            
-            gxobject = Agent(id=record.xref)
-            self.gedcomx.add_agent(gxobject)
+            if (gxobject := self.gedcomx.agents.byId(id=record.xref)) is None:
+                gxobject = Agent(id=record.xref)
+                self.gedcomx.add_agent(gxobject)
             
             self.object_map[record.level] = gxobject
             
@@ -852,7 +915,6 @@ class GedcomConverter():
                 self.object_map[record.level] = gxobject
 
             else:
-                print("handle_repo",record.describe())
                 raise ValueError()
                 gxobject = Agent(names=[TextValue(record.value)])
         else:
@@ -899,30 +961,39 @@ class GedcomConverter():
             assert False
 
     def handle_sour(self, record: Gedcom5xRecord):
-        if record.level == 0 or record.tag == '_WLNK' or (record.level == 0 and record.tag == 'OBJE'):
-            source_description = SourceDescription(id=record.xref.replace('@','') if record.xref else None)
-            self.gedcomx.add_source_description(source_description)
+        if record.level == 0 and (record.tag in ['SOUR','OBJE','_WLNK']):
             
-            self.object_map[record.level] = source_description
-        else:
-            # This 'SOUR' is a SourceReference
-            if record.xref is None or record.xref.strip() == '':
-                log.warning(f"SOUR points to nothing: {record.describe()}")
-                return False
-            if self.gedcomx.source_descriptions.byId(record.xref):
-                gxobject = SourceReference(descriptionId=record.xref, description=self.gedcomx.source_descriptions.byId(record.xref))
+            if (gxobject := self.gedcomx.sourceDescriptions.byId(record.xref)) is None:
+                log.debug(f"SourceDescription with id: {record.xref} was not found. Creating a new SourceDescription")
+                log.debug(f"Creating SourceDescription from {record.tag} {record.describe()}")
+                gxobject = SourceDescription(id=record.xref)
+                self.object_map[record.level-1].add_source_description(gxobject)
+            else:
+                log.debug(f"Found SourceDescription with id:{record.xref}")
+            
+        elif (add_method := getattr(self.object_map[record.level-1],"add_source_reference",None)) is not None:
+            if (source_description := self.gedcomx.sourceDescriptions.byId(record.xref)) is not None:
+                gxobject = SourceReference(descriptionId=record.xref, description=source_description)
+                add_method(gxobject)
             else:
-                log.warning(f'Could not find source with id: {record.xref}')
-                source_description = SourceDescription(id=record.xref)
-                gxobject = SourceReference(descriptionId=record.value, description=source_description)
-            if isinstance(self.object_map[record.level-1],SourceReference):
-                self.object_map[record.level-1].description.add_source(gxobject)
-            elif record.parent is not None and record.parent.tag in ['NOTE']:
-                pass
+                log.error(f"Could not find source with id: {record.xref}, Creating Place Holder Description")
+                gxobject = SourceDescription(id=record.xref)
+                gxobject._place_holder = True
+                gxobject = SourceReference(descriptionId=record.xref, description=gxobject)
+
+        elif record.tag == 'OBJE' and isinstance(self.object_map[record.level-1],SourceReference):
+            if (source_description := self.gedcomx.sourceDescriptions.byId(record.xref)) is not None:
+                gxobject = SourceReference(descriptionId=record.xref, description=source_description)
+                self.object_map[record.level-1].description.add_source_reference(gxobject)
             else:
-                self.object_map[record.level-1].add_source(gxobject)
+                assert False
+
+        else:
+            print(record.describe())
+            print(self.object_map)
+            assert False
             
-            self.object_map[record.level] = gxobject
+        self.object_map[record.level] = gxobject
           
     def handle_stae(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-1], Address):
@@ -955,8 +1026,6 @@ class GedcomConverter():
             
             gxobject = TextValue(value=self.clean_str(record.value))
             self.object_map[record.level-1].add_title(gxobject)
-
-            
             self.object_map[record.level] = gxobject
         
         elif record.parent is not None and record.parent.tag == 'FILE' and isinstance(self.object_map[record.level-2], SourceDescription):
@@ -982,8 +1051,7 @@ class GedcomConverter():
                 self.object_map[record.level-1].type = EventType.guess(record.value)                
             else:
                 log.warning(f"Could not determine type of event with value '{record.value}'")  
-                assert False            
-                self.object_map[record.level-1].type = None
+            # add as a note anyway, guess works of text in the string    
             self.object_map[record.level-1].add_note(Note(text=self.clean_str(record.value)))
         elif isinstance(self.object_map[record.level-1], Fact):
             if not self.object_map[record.level-1].type:
@@ -996,9 +1064,11 @@ class GedcomConverter():
         elif record.parent is not None and record.parent.tag == 'FORM':
             if not self.object_map[0].mediaType:
                 self.object_map[0].mediaType = record.value
+        elif isinstance(self.object_map[record.level-1], Name):
+            self.object_map[record.level-1].type = GedcomConverter.type_name_type.get(record.value,NameType.Other)
 
         else:
-            raise ValueError(f"I do not know how to handle 'TYPE' tag for {type(self.object_map[record.level-1])}")
+            raise TagConversionError(record,self.object_map)
 
     def handle__url(self, record: Gedcom5xRecord):
         if isinstance(self.object_map[record.level-2], SourceDescription):
@@ -1014,6 +1084,50 @@ class GedcomConverter():
         else:
             raise ValueError(f"Could not handle 'WWW' tag in record {record.describe()}, last stack object {self.object_map[record.level-1]}")
 
+    def parse_gedcom5x_fam_record(self, record: Gedcom5xRecord):
+        log.info(f"Parsing family recrods")
+        with open('./logs/gedcomx.convert.families.json', 'a') as f:
+            for fam in record._flatten_subrecords(record):
+                f.write(fam.describe() + "\n")
+
+    def print_counts_table(self, counts: Mapping[Any, int]) -> None:
+        """
+        Pretty-print {key: int} as columns, largest count first.
+        Column count adapts to terminal width and number of items.
+        """
+        items = [(str(k), int(v)) for k, v in counts.items()]
+        if not items:
+            print("(empty)")
+            return
+
+        # Sort: by value desc, then key asc for stable ordering
+        items.sort(key=lambda kv: (-kv[1], kv[0]))
+
+        # Cell formatting widths
+        key_w = max(len(k) for k, _ in items)
+        num_w = max(len(str(v)) for _, v in items)
+        cell_fmt = f"{{k:<{key_w}}}  {{v:>{num_w}}}"  # e.g., 'Surname        123'
+        cell_width = key_w + 2 + num_w + 2            # +2 padding between columns
+
+        # Decide number of columns: fit to terminal, but also scale with item count
+        term_cols = shutil.get_terminal_size(fallback=(100, 24)).columns
+        fit_cols = max(1, term_cols // cell_width)
+        sqrt_cols = max(1, int(math.sqrt(len(items))))  # more cols when many items
+        cols = max(1, min(len(items), max(fit_cols, sqrt_cols)))
+
+        rows = math.ceil(len(items) / cols)
+
+        # Print row-wise, reading items column-major so columns stay balanced
+        for r in range(rows):
+            line = []
+            for c in range(cols):
+                i = c * rows + r
+                if i < len(items):
+                    k, v = items[i]
+                    cell = cell_fmt.format(k=k, v=v)
+                    line.append(cell.ljust(cell_width))
+            print("".join(line).rstrip())
+
     def Gedcom5x_GedcomX(self, gedcom5x: Gedcom5x):
         print(f'Parsing GEDCOM Version {gedcom5x.version}')
         individual_ids = set()
@@ -1021,29 +1135,45 @@ class GedcomConverter():
         repository_ids = set()
         family_ids = set()
 
-        if gedcom5x:
-            for individual in gedcom5x.individuals:
-                individual_ids.add(individual.xref)
-                gx_obj = Person(id=individual.xref)
-                self.gedcomx.add_person(gx_obj)
+        with hub.use(convert_log):
+            if gedcom5x:
+                for object in gedcom5x.objects:
+                    log.debug(f"Priming Source id's with id: {object.xref} from objects")
+                    source_ids.add(object.xref)
+                    gx_obj = SourceDescription(id=object.xref)
+                    self.gedcomx.add_source_description(gx_obj)
+
+                for source in gedcom5x.sources:
+                    source_ids.add(source.xref)
+                    gx_obj = SourceDescription(id=source.xref)
+                    self.gedcomx.add_source_description(gx_obj)
+                
+                for repo in gedcom5x.repositories:
+                    repository_ids.add(repo.xref)
+                    gx_obj = Agent(id=repo.xref)
+                    self.gedcomx.add_agent(gx_obj)
+                
+                for individual in gedcom5x.individuals:
+                    individual_ids.add(individual.xref)
+                    gx_obj = Person(id=individual.xref)
+                    self.gedcomx.add_person(gx_obj)
                 
+                for family in gedcom5x.families:
+                    family_ids.add(family.xref)
+                    self.handle_fam(family)
+                
+                # Now Parse Zero Level Recrods
+                for source in gedcom5x.sources:
+                    self.parse_gedcom5x_record(source)
+                for object in gedcom5x.objects:
+                    self.parse_gedcom5x_record(object)
+                for individual in gedcom5x.individuals:
+                    self.parse_gedcom5x_record(individual)
+                for repo in gedcom5x.repositories:
+                    self.parse_gedcom5x_record(repo)
+                for family in gedcom5x.families:
+                    self.parse_gedcom5x_record(family)
+        
+        self.print_counts_table(self.missing_handler_count)
         
-            for source in gedcom5x.sources:
-                source_ids.add(source.xref)
-                gx_obj = SourceDescription(id=source.xref)
-                self.gedcomx.add_source_description(gx_obj)
-            
-            for source in gedcom5x.repositories:
-                repository_ids.add(source.xref)
-                gx_obj = Agent(id=source.xref)
-                self.gedcomx.add_agent(gx_obj)
-            
-            for family in gedcom5x.families:
-                family_ids.add(family.xref)
-                self.handle_fam(family)
-            
-            # Now Parse Zero Level Recrods
-            for individual in gedcom5x.individuals:
-                self.parse_gedcom5x_recrod(individual)
-
         return self.gedcomx

gedcomx/coverage.py

@@ -8,7 +8,7 @@ from typing import Optional
 
  Created: 2025-08-25
  Updated:
-   - 2025-08-31: 
+   - 2025-09-03: _from_json_ refactor 
    
 ======================================================================
 """
@@ -20,6 +20,15 @@ GEDCOM Module Types
 """
 from .date import Date
 from .place_reference import PlaceReference
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 
 class Coverage:

gedcomx/date.py

@@ -1,9 +1,34 @@
-from typing import Optional
+from typing import Any, Optional, Dict
 from datetime import datetime, timezone
 from dateutil import parser
-import time
-
-
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    date.py
+ Author:  David J. Cartwright
+ Purpose: 
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json refactored
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 
 class DateFormat:
@@ -31,14 +56,23 @@ class Date:
             type_as_dict['original'] = self.original
         if self.formal:
             type_as_dict['formal'] = self.formal
+        return type_as_dict if type_as_dict != {} else None
         return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
-    def _from_json_(cls,data):
-        original = data.get('original',None)
-        formal = data.get('formal',None)
+    def _from_json_(cls,data: Any, context=None):
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)} data:{data}")
+
+        date_data: Dict[str, Any] = {}
+
+        # Scalars
+        if (orig := data.get("original")) is not None:
+            date_data["original"] = orig
+        if (formal := data.get("formal")) is not None:
+            date_data["formal"] = formal
         
-        return Date(original=original,formal=formal)
+        return cls(**date_data)
         
 
 

gedcomx/document.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Optional, List
+from typing import Any, Dict, List, Optional
 """
 ======================================================================
  Project: Gedcom-X
@@ -9,7 +9,7 @@ from typing import Optional, List
 
  Created: 2025-08-25
  Updated:
-   - 2025-08-31: 
+   - 2025-09-03: _from_json_ refactored 
    
 ======================================================================
 """
@@ -24,6 +24,15 @@ from .conclusion import Conclusion, ConfidenceLevel
 from .note import Note
 from .resource import Resource
 from .source_reference import SourceReference
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+serial_log = "gedcomx.serialization"
+#=====================================================================
 
 
 class DocumentType(Enum):
@@ -83,10 +92,31 @@ class Document(Conclusion):
         return Serialization.serialize_dict(type_as_dict)
     
     @classmethod
-    def _from_json_(cls, data: dict):
+    def _from_json_(cls, data: Any, context: Any = None) -> "Document":
         """
-        Create a Person instance from a JSON-dict (already parsed).
+        Build a Document from JSON.
+        Shorthand: a bare string becomes {'text': <string>}.
         """
-        from .serialization import Serialization
-        type_as_dict = Serialization.get_class_fields('Document')
-        return Serialization.deserialize(type_as_dict,Document)
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}._from_json_ expected dict or str, got {type(data)}")
+
+        obj: Dict[str, Any] = Conclusion._dict_from_json_(data,context)
+
+        # type (enum)
+        if (typ := data.get("type")) is not None:
+            obj["type"] = DocumentType(typ)
+            
+
+        # extracted (bool; accept common string forms)
+        if (ex := data.get("extracted")) is not None:
+            obj["extracted"] = bool(ex)
+
+        # textType (enum)
+        if (tt := data.get("textType")) is not None:
+            obj["textType"] = TextType(tt) 
+
+        # text (string)
+        if (tx := data.get("text")) is not None:
+            obj["text"] = str(tx)
+
+        return cls(**obj)