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

gedcomx/{Converter.py → converter.py}

@@ -1,52 +1,86 @@
 DEBUG = False
-import base64
-import json
+import logging
 import mimetypes
 import re
-import uuid
 import xml.etree.ElementTree as ET
 
-from typing import List, Optional, Any
-from xml.dom import minidom
-from .Address import Address
-from .Agent import Agent
-from .Attribution import Attribution
-from .Conclusion import Conclusion
-from .Coverage import Coverage
-from .Date import Date, date_to_timestamp
-from .Document import Document
-from .EvidenceReference import EvidenceReference
-from .Exceptions import TagConversionError
-from .Event import Event,EventType,EventRole,EventRoleType
-from .Fact import Fact, FactType, FactQualifier
-from .Gedcom import Gedcom
-from .Gedcom5x import Gedcom5x, Gedcom5xRecord
-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 .Name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
-from .Note import Note
-from .OnlineAccount import OnlineAccount
-from .Person import Person
-from .PlaceDescription import PlaceDescription
-from .PlaceReference import PlaceReference
-from .Qualifier import Qualifier
-from .Relationship import Relationship, RelationshipType
-from .SourceCitation import SourceCitation
-from .SourceDescription import SourceDescription, ResourceType
-from .SourceReference import SourceReference, KnownSourceReference
-#from .Subject import Subject
-from .TextValue import TextValue
-from .TopLevelTypeCollection import TopLevelTypeCollection
-from .Resource import Resource, URI
+from typing import Any, Mapping
+import math
+import shutil
+
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    converter.py
+ Author:  David J. Cartwright
+ Purpose: convert gedcom versions
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-01: added docs and fixed imports for lowercase module names
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+
+from .address import Address
+from .agent import Agent
+from .attribution import Attribution
+from .conclusion import Conclusion
+from .coverage import Coverage
+from .date import Date, date_to_timestamp
+from .document import Document
+from .evidence_reference import EvidenceReference
+from .exceptions import TagConversionError
+from .event import Event, EventType, EventRole, EventRoleType
+from .fact import Fact, FactType, FactQualifier
+from .gedcom import Gedcom
+from .gedcom5x import Gedcom5x, Gedcom5xRecord
+from .gedcomx import GedcomX
+from .gender import Gender, GenderType
+from .group import Group
+from .identifier import Identifier, IdentifierType, make_uid, IdentifierList
+from .logging_hub import hub, ChannelConfig
+from .name import Name, NameType, NameForm, NamePart, NamePartType, NamePartQualifier
+from .note import Note
+from .online_account import OnlineAccount
+from .person import Person
+from .place_description import PlaceDescription
+from .place_reference import PlaceReference
+from .qualifier import Qualifier
+from .relationship import Relationship, RelationshipType
+from .resource import Resource
+from .source_citation import SourceCitation
+from .source_description import SourceDescription, ResourceType
+from .source_reference import SourceReference, KnownSourceReference
+# from .subject import Subject
+from .textvalue import TextValue
+#from .topleveltypecollection import TopLevelTypeCollection
+from .uri import URI
+from .logging_hub import hub, logging
+"""
+======================================================================
+Logging
+======================================================================
+"""
+log = logging.getLogger("gedcomx")
+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
+    ))
 
-import logging
-from .LoggingHub import hub, ChannelConfig
-log = logging.getLogger("gedcomx")
-job_id = "gedcomx.convert.GEDCOM5x"
 
 class GedcomConverter():
     def __init__(self) -> None:
@@ -54,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,
@@ -142,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
@@ -151,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
@@ -167,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])}")
 
@@ -322,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?
@@ -508,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)
@@ -540,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')
@@ -583,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
 
@@ -606,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':
@@ -626,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):
@@ -643,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')
@@ -661,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)
 
@@ -674,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)
@@ -729,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):
@@ -822,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
             
@@ -837,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:
@@ -884,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.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.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.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):
@@ -940,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):
@@ -967,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:
@@ -981,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):
@@ -999,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()
@@ -1006,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

@@ -0,0 +1,64 @@
+from typing import Optional
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    coverage.py
+ Author:  David J. Cartwright
+ Purpose: 
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-09-03: _from_json_ refactor 
+   
+======================================================================
+"""
+
+"""
+======================================================================
+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:
+    identifier = 'http://gedcomx.org/v1/Coverage'
+    version = 'http://gedcomx.org/conceptual-model/v1'
+
+    def __init__(self,spatial: Optional[PlaceReference], temporal: Optional[Date]) -> None:
+        self.spatial = spatial
+        self.temporal = temporal    
+    
+    # ...existing code...
+
+    @property
+    def _as_dict_(self):
+        from .serialization import Serialization
+        type_as_dict = {}
+        if self.spatial:
+            type_as_dict['spatial'] = getattr(self.spatial, '_as_dict_', self.spatial)
+        if self.temporal:  # (fixed: no space after the dot)
+            type_as_dict['temporal'] = getattr(self.temporal, '_as_dict_', self.temporal)
+        return Serialization.serialize_dict(type_as_dict) 
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Coverage instance from a JSON-dict (already parsed).
+        """
+        from .place_reference import PlaceReference
+        from .date import Date
+
+        spatial = PlaceReference._from_json_(data.get('spatial')) if data.get('spatial') else None
+        temporal = Date._from_json_(data.get('temporal')) if data.get('temporal') else None
+        return cls(spatial=spatial, temporal=temporal)