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

gedcomx/LoggingHub.py

@@ -0,0 +1,186 @@
+# logging_hub.py
+from __future__ import annotations
+import logging
+import contextvars
+from contextlib import contextmanager
+from dataclasses import dataclass
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Dict, Optional
+
+# Context key: which "channel" (log) is current?
+_current_channel: contextvars.ContextVar[str] = contextvars.ContextVar("current_log_channel", default="default")
+
+def get_current_channel() -> str:
+    return _current_channel.get()
+
+def set_current_channel(name: str) -> None:
+    _current_channel.set(name)
+
+class ChannelFilter(logging.Filter):
+    """Injects the current channel into every LogRecord."""
+    def filter(self, record: logging.LogRecord) -> bool:
+        record.log_channel = get_current_channel()
+        return True
+
+class DispatchingHandler(logging.Handler):
+    """
+    Routes records to a per-channel handler (file/stream), based on LogRecord.log_channel
+    which is set by ChannelFilter.
+    """
+    def __init__(self):
+        super().__init__()
+        self._channel_handlers: Dict[str, logging.Handler] = {}
+        self._enabled: Dict[str, bool] = {}
+        self._default_channel = "default"
+
+    def set_default_channel(self, name: str) -> None:
+        self._default_channel = name
+
+    def add_channel(self, name: str, handler: logging.Handler, enabled: bool = True) -> None:
+        self._channel_handlers[name] = handler
+        self._enabled[name] = enabled
+
+    def enable(self, name: str) -> None:
+        self._enabled[name] = True
+
+    def disable(self, name: str) -> None:
+        self._enabled[name] = False
+
+    def remove_channel(self, name: str) -> None:
+        h = self._channel_handlers.pop(name, None)
+        self._enabled.pop(name, None)
+        if h:
+            try:
+                h.flush()
+                h.close()
+            except Exception:
+                pass
+
+    def has_channel(self, name: str) -> bool:
+        return name in self._channel_handlers
+
+    def emit(self, record: logging.LogRecord) -> None:
+        channel = getattr(record, "log_channel", None) or self._default_channel
+        handler = self._channel_handlers.get(channel) or self._channel_handlers.get(self._default_channel)
+        if not handler:
+            return  # nothing to write to
+        if not self._enabled.get(channel, True):
+            return  # channel muted
+        handler.emit(record)
+
+@dataclass
+class ChannelConfig:
+    name: str
+    path: Optional[str] = None
+    level: int = logging.INFO
+    fmt: str = "[%(asctime)s] %(levelname)s %(log_channel)s %(name)s: %(message)s"
+    datefmt: str = "%Y-%m-%d %H:%M:%S"
+    rotation: Optional[str] = None
+    # rotation options:
+    #   None                     -> plain FileHandler
+    #   "size:10MB:3"            -> RotatingFileHandler(maxBytes=10MB, backupCount=3)
+    #   "time:midnight:7"        -> TimedRotatingFileHandler(when="midnight", backupCount=7)
+
+class LoggingHub:
+    """
+    A centralized, context-aware logging hub.
+    Usage:
+        hub = LoggingHub()
+        hub.init_root()  # do once at startup
+        hub.start_channel(ChannelConfig(name="default", path="logs/default.log"))
+        hub.set_current("default")
+
+        # In any module:
+        log = logging.getLogger("gedcomx")
+        log.info("hello")  # goes to current channel
+
+        with hub.use("import-job-42"):
+            log.info("within job 42")
+    """
+    def __init__(self, root_logger_name: str = "gedcomx"):
+        self.root_name = root_logger_name
+        self._root = logging.getLogger(self.root_name)
+        self._dispatch = DispatchingHandler()
+        self._root.setLevel(logging.DEBUG)  # Let handlers control final level
+
+        self._filter = ChannelFilter()
+        self._initialized = False
+
+    # -------- Initialization --------
+    def init_root(self) -> None:
+        if self._initialized:
+            return
+        # Clean existing handlers on the root logger (optional safety)
+        for h in list(self._root.handlers):
+            self._root.removeHandler(h)
+        self._root.addFilter(self._filter)
+        self._root.addHandler(self._dispatch)
+        self._initialized = True
+
+    # -------- Channel Management --------
+    def start_channel(self, cfg: ChannelConfig, make_current: bool = False, enabled: bool = True) -> None:
+        """Create/replace a channel with a file/rotating handler."""
+        handler: logging.Handler
+        formatter = logging.Formatter(cfg.fmt, datefmt=cfg.datefmt)
+
+        if cfg.path is None:
+            # StreamHandler to stdout if no path provided
+            handler = logging.StreamHandler()
+        else:
+            # Rotation options
+            if cfg.rotation and cfg.rotation.startswith("size:"):
+                # "size:10MB:3"
+                _, size_str, backups_str = cfg.rotation.split(":")
+                size_str = size_str.upper().replace("MB", "*1024*1024").replace("KB", "*1024")
+                max_bytes = int(eval(size_str))  # safe for the limited substitutions we made
+                backup_count = int(backups_str)
+                handler = RotatingFileHandler(cfg.path, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8")
+            elif cfg.rotation and cfg.rotation.startswith("time:"):
+                # "time:midnight:7" or "time:H:24"
+                parts = cfg.rotation.split(":")
+                when = parts[1]
+                backup_count = int(parts[2]) if len(parts) > 2 else 7
+                handler = TimedRotatingFileHandler(cfg.path, when=when, backupCount=backup_count, encoding="utf-8", utc=False)
+            else:
+                handler = logging.FileHandler(cfg.path, encoding="utf-8")
+
+        handler.setLevel(cfg.level)
+        handler.setFormatter(formatter)
+
+        # Replace if exists
+        if self._dispatch.has_channel(cfg.name):
+            self._dispatch.remove_channel(cfg.name)
+        self._dispatch.add_channel(cfg.name, handler, enabled=enabled)
+
+        if make_current:
+            self.set_current(cfg.name)
+
+    def stop_channel(self, name: str) -> None:
+        self._dispatch.remove_channel(name)
+
+    def enable(self, name: str) -> None:
+        self._dispatch.enable(name)
+
+    def disable(self, name: str) -> None:
+        self._dispatch.disable(name)
+
+    def list_channels(self) -> Dict[str, bool]:
+        """Return dict of channel -> enabled?"""
+        return {name: enabled for name, enabled in self._dispatch._enabled.items()}
+
+    # -------- Current Channel --------
+    def set_current(self, name: str) -> None:
+        set_current_channel(name)
+
+    @contextmanager
+    def use(self, name: str):
+        """Temporarily switch to a channel within a with-block."""
+        token = _current_channel.set(name)
+        try:
+            yield
+        finally:
+            _current_channel.reset(token)
+
+    # -------- Utilities --------
+    def set_default_channel(self, name: str) -> None:
+        self._dispatch.set_default_channel(name)

gedcomx/Mutations.py

@@ -0,0 +1,228 @@
+from .Gedcom5x import GedcomRecord
+from .Fact import Fact, FactType
+from .Event import Event, EventType
+
+fact_event_table = {
+    # Person Fact / Event Types
+    "ADOP": {
+        "Fact": FactType.AdoptiveParent,
+        "Event": EventType.Adoption,
+    },
+    "CHR": {
+        "Fact": FactType.AdultChristening,
+        "Event": EventType.AdultChristening,
+    },
+    "EVEN": {
+        "Fact": FactType.Amnesty,
+        # no Event
+    },
+    "BAPM": {
+        "Fact": FactType.Baptism,
+        "Event": EventType.Baptism,
+    },
+    "BARM": {
+        "Fact": FactType.BarMitzvah,
+        "Event": EventType.BarMitzvah,
+    },
+    "BASM": {
+        "Fact": FactType.BatMitzvah,
+        "Event": EventType.BatMitzvah,
+    },
+    "BIRT": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BIRT, CHR": {
+        "Fact": FactType.Birth,
+        "Event": EventType.Birth,
+    },
+    "BLES": {
+        "Fact": FactType.Blessing,
+        "Event": EventType.Blessing,
+    },
+    "BURI": {
+        "Fact": FactType.Burial,
+        "Event": EventType.Burial,
+    },
+    "CAST": {
+        "Fact": FactType.Caste,
+        # no Event
+    },
+    "CENS": {
+        "Fact": FactType.Census,
+        "Event": EventType.Census,
+    },
+    "CIRC": {
+        "Fact": FactType.Circumcision,
+        "Event": EventType.Circumcision,
+    },
+    "CONF": {
+        "Fact": FactType.Confirmation,
+        "Event": EventType.Confirmation,
+    },
+    "CREM": {
+        "Fact": FactType.Cremation,
+        "Event": EventType.Cremation,
+    },
+    "DEAT": {
+        "Fact": FactType.Death,
+        "Event": EventType.Death,
+    },
+    "EDUC": {
+        "Fact": FactType.Education,
+        "Event": EventType.Education,
+    },
+    "EMIG": {
+        "Fact": FactType.Emigration,
+        "Event": EventType.Emigration,
+    },
+    "FCOM": {
+        "Fact": FactType.FirstCommunion,
+        "Event": EventType.FirstCommunion,
+    },
+    "GRAD": {
+        "Fact": FactType.Graduation,
+        # no Event
+    },
+    "IMMI": {
+        "Fact": FactType.Immigration,
+        "Event": EventType.Immigration,
+    },
+    "MIL": {
+        "Fact": FactType.MilitaryService,
+        # no Event
+    },
+    "NATI": {
+        "Fact": FactType.Nationality,
+        # no Event
+    },
+    "NATU": {
+        "Fact": FactType.Naturalization,
+        "Event": EventType.Naturalization,
+    },
+    "OCCU": {
+        "Fact": FactType.Occupation,
+        # no Event
+    },
+    "ORDN": {
+        "Fact": FactType.Ordination,
+        "Event": EventType.Ordination,
+    },
+    "DSCR": {
+        "Fact": FactType.PhysicalDescription,
+        # no Event
+    },
+    "PROB": {
+        "Fact": FactType.Probate,
+        # no Event
+    },
+    "PROP": {
+        "Fact": FactType.Property,
+        # no Event
+    },
+    "RELI": {
+        "Fact": FactType.Religion,
+        # no Event
+    },
+    "RESI": {
+        "Fact": FactType.Residence,
+        # no Event
+    },
+    "WILL": {
+        "Fact": FactType.Will,
+        # no Event
+    },
+
+    # Couple Relationship Fact / Event Types
+    "ANUL": {
+        "Fact": FactType.Annulment,
+        "Event": EventType.Annulment,
+    },
+    "DIV": {
+        "Fact": FactType.Divorce,
+        "Event": EventType.Divorce,
+    },
+    "DIVF": {
+        "Fact": FactType.DivorceFiling,
+        "Event": EventType.DivorceFiling,
+    },
+    "ENGA": {
+        "Fact": FactType.Engagement,
+        "Event": EventType.Engagement,
+    },
+    "MARR": {
+        "Fact": FactType.Marriage,
+        "Event": EventType.Marriage,
+    },
+    "MARB": {
+        "Fact": FactType.MarriageBanns,
+        # no Event
+    },
+    "MARC": {
+        "Fact": FactType.MarriageContract,
+        # no Event
+    },
+    "MARL": {
+        "Fact": FactType.MarriageLicense,
+        # no Event
+    },
+    "MARS":{
+        "Fact":EventType.MarriageSettlment
+
+    },
+    "SEPA": {
+        "Fact": FactType.Separation,
+        # no Event
+    },
+
+}
+
+class GedcomXObject:
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        self.created_with_tag: str = record.tag if record and isinstance(record, GedcomRecord) else None    
+        self.created_at_level: int = record.level if record and isinstance(record, GedcomRecord) else None
+        self.created_at_line_number: int = record.line_number if record and isinstance(record, GedcomRecord) else None
+
+class GedcomXSourceOrDocument(GedcomXObject):
+    def __init__(self,record: GedcomRecord | None = None) -> None:
+        super().__init__(record)
+        self.title: str = None
+        self.citation: str = None
+        self.page: str = None
+        self.contributor: str = None
+        self.publisher: str = None
+        self.rights: str = None
+        self.url: str = None
+        self.medium: str = None
+        self.type: str = None
+        self.format: str = None
+        self.created: str = None
+        self.modified: str = None
+        self.language: str = None
+        self.relation: str = None
+        self.identifier: str = None
+        self.description: str = None
+
+class GedcomXEventOrFact(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+        super().__init__(record)
+        if record.tag in fact_event_table.keys():
+
+            if 'Fact' in fact_event_table[record.tag].keys():
+                obj = Fact(type=fact_event_table[record.tag]['Fact'])
+                return obj
+            elif 'Event' in fact_event_table[record.tag].keys():
+                obj = Event(type=fact_event_table[record.tag]['Fact'])
+            else:
+                raise ValueError
+        else:
+            raise ValueError(f"{record.tag} not found in map")
+
+class GedcomXRelationshipBuilder(GedcomXObject):
+    def __new__(cls,record: GedcomRecord | None = None, object_stack: dict | None = None) -> object:
+        last_relationship = object_stack.get('lastrelationship',None)
+        last_relationship_data = object_stack.get('lastrelationshipdata',None)
+        if not isinstance(last_relationship_data,dict):
+            last_relationship_data = None
+
+        

gedcomx/Name.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import List,Optional
+from typing_extensions import Self
 
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
@@ -220,6 +221,11 @@ class Name(Conclusion):
     
         return name_as_dict
 
+class QuickName():
+    def __new__(cls,name: str) -> Name:
+        obj = Name(nameForms=[NameForm(fullText=name)])
+        return obj
+    
 def ensure_list(val):
     if val is None:
         return []

gedcomx/Person.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import List, Optional
+from urllib.parse import urljoin
 
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
@@ -8,13 +9,14 @@ from .EvidenceReference import EvidenceReference
 from .Fact import Fact, FactType
 from .Gender import Gender, GenderType
 from .Identifier import IdentifierList
-from .Name import Name
+from .Name import Name, QuickName
 from .Note import Note
 from .SourceReference import SourceReference
+from .Serialization import Serialization
 from .Subject import Subject
 from .Resource import Resource
 from collections.abc import Sized
-from ._Links import _LinkList
+from .Extensions.rs10.rsLink import _rsLinkList
 
 class Person(Subject):
     """A person in the system.
@@ -47,9 +49,10 @@ class Person(Subject):
              names: Optional[List[Name]] = None,
              facts: Optional[List[Fact]] = None,
              living: Optional[bool] = False,
-             links: Optional[_LinkList] = None) -> None:
+             links: Optional[_rsLinkList] = None,
+             uri: Optional[Resource] = None) -> None:
         # Call superclass initializer if needed
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers,links=links)
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers,links=links,uri=uri)
         
         # Initialize mutable attributes to empty lists if None
         self.sources = sources if sources is not None else []
@@ -108,103 +111,59 @@ class Person(Subject):
 
     @property
     def _as_dict_(self):
-        def _serialize(value):
-            if isinstance(value, (str, int, float, bool, type(None))):
-                return value
-            elif isinstance(value, dict):
-                return {k: _serialize(v) for k, v in value.items()}
-            elif isinstance(value, (list, tuple, set)):
-                return [_serialize(v) for v in value]
-            elif hasattr(value, "_as_dict_"):
-                return value._as_dict_
-            else:
-                return str(value)  # fallback for unknown objects
-
-        subject_fields = super()._as_dict_  # Start with base class fields
+        type_as_dict = super()._as_dict_  # Start with base class fields
         # Only add Relationship-specific fields
-        subject_fields.update({
+        type_as_dict.update({
             'private': self.private,
             'living': self.living,
             'gender': self.gender._as_dict_ if self.gender else None,
             'names': [name._as_dict_ for name in self.names],
-            'facts': [fact for fact in self.facts],
-            'uri': 'uri: ' + self.uri.value
+            'facts': [fact._as_dict_ for fact in self.facts],
+            'uri': self.uri._as_dict_ if self.uri else None
                            
         })
 
-        # Serialize and exclude None values
-        for key, value in subject_fields.items():
-            if value is not None:
-                subject_fields[key] = _serialize(value)
-
-        # 3) merge and filter out None *at the top level*
-        return {
-                k: v
-                for k, v in subject_fields.items()
-                if v is not None and not (isinstance(v, Sized) and len(v) == 0)
-            }
-        
-        
+        return Serialization.serialize_dict(type_as_dict)
+           
     @classmethod
     def _from_json_(cls, data: dict):
         """
         Create a Person instance from a JSON-dict (already parsed).
         """
-        
-        
-        # Basic scalar fields
-        id_        = data.get('id')
-        lang       = data.get('lang', 'en')
-        private    = data.get('private', False)
-        extracted  = data.get('extracted', False)
-
-        living  = data.get('extracted', False)
-
-        # Complex singletons
-        analysis    = Resource._from_json_(data['analysis']) if data.get('analysis') else None
-        attribution = Attribution._from_json_(data['attribution']) if data.get('attribution') else None
-        confidence  = ConfidenceLevel_from_json_(data['confidence']) if data.get('confidence') else None
-
-        # Gender (string or dict depending on your JSON)
-        gender_json = data.get('gender')
-        if isinstance(gender_json, dict):
-            gender = Gender._from_json_(gender_json)
-        else:
-            # if it's just the enum value
-            gender = Gender(type=GenderType(gender_json)) if gender_json else Gender(type=GenderType.Unknown)
-        
-        
-        sources     = [SourceReference._from_json_(o)   for o in data.get('sources')] if data.get('sources') else None
-        notes       = [Note._from_json_(o)              for o in data.get('notes')] if data.get('notes') else None
-        evidence    = [EvidenceReference._from_json_(o) for o in data.get('evidence')] if data.get('evidence') else None
-        media       = [SourceReference._from_json_(o)   for o in data.get('media')] if data.get('media') else None
-        identifiers = IdentifierList._from_json_(data.get('identifiers'))      if data.get('identifiers') else None
-        names       = [Name._from_json_(o)              for o in data.get('names')] if data.get('names') else None
-        facts       = [Fact._from_json_(o)              for o in data.get('facts')] if data.get('facts') else None
-        links       = _LinkList._from_json_(data.get('links'))     if data.get('links') else None
-
-        # Build the instance
-        inst = cls(
-            id          = id_,
-            lang        = lang,
-            sources     = sources,
-            analysis    = analysis,
-            notes       = notes,
-            confidence  = confidence,
-            attribution = attribution,
-            extracted   = extracted,
-            evidence    = evidence,
-            media       = media,
-            identifiers = identifiers,
-            private     = private,
-            gender      = gender,
-            names       = names,
-            facts       = facts,
-            living      = living,
-            links       = links
-        )
-
-        return inst
+        return Serialization.deserialize(data, Person)
+
+    @classmethod
+    def from_familysearch(cls, pid: str, token: str, *, base_url: Optional[str] = None):
+        """
+        Fetch a single person by PID from FamilySearch and return a Person.
+        - pid: e.g. "KPHP-4B4"
+        - token: OAuth2 access token (Bearer)
+        - base_url: override API base (defaults to settings.FS_API_BASE or prod)
+        """
+        import requests
+        default_base = "https://apibeta.familysearch.org/platform/"
+
+        base = (base_url or default_base).rstrip("/") + "/"
+        url = urljoin(base, f"tree/persons/{pid}")
+
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {token}",
+        }
+
+        resp = requests.get(url, headers=headers, timeout=(5, 30))
+        resp.raise_for_status()
+
+        payload = resp.json()
+        persons = payload.get("persons") or []
+
+        # Prefer exact match on PID, else first item if present
+        person_json = next((p for p in persons if (p.get("id") == pid)), None) or (persons[0] if persons else None)
+        if not person_json:
+            raise ValueError(f"FamilySearch returned no person for PID {pid}")
+
+        # Keep your existing deserialization helper
+        return Serialization.deserialize(person_json, Person)    
 
 class QuickPerson:
     """A GedcomX Person Data Type created with basic information.
@@ -221,7 +180,7 @@ class QuickPerson:
     Raises:
         ValueError: If `id` is not a valid UUID.
     """
-    def __new__(cls, name: Optional[str], dob: Optional[str], dod: Optional[str]):
+    def __new__(cls, name: str, dob: Optional[str] = None, dod: Optional[str] = None):
         # Build facts from args
         facts = []
         if dob:
@@ -230,4 +189,4 @@ class QuickPerson:
             facts.append(Fact(type=FactType.Death, date=Date(original=dod)))
 
         # Return the different class instance
-        return Person(facts=facts, names=[name] if name else None)
+        return Person(facts=facts, names=[QuickName(name=name)] if name else None)