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

gedcomx/PlaceDescription.py

@@ -17,17 +17,18 @@ class PlaceDescription(Subject):
     identifier = "http://gedcomx.org/v1/PlaceDescription"
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str =None,
+    def __init__(self, id: Optional[str] =None,
                  lang: str = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Resource = None, notes: Optional[List[Note]] =[],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
-                 extracted: bool = None,
-                 evidence: List[EvidenceReference] = None,
-                 media: List[SourceReference] = [],
-                 identifiers: List[IdentifierList] = [],
-                 names: List[TextValue] = [],
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[Resource] = None,
+                 notes: Optional[List[Note]] =None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 extracted: Optional[bool] = None,
+                 evidence: Optional[List[EvidenceReference]] = None,
+                 media: Optional[List[SourceReference]] = None,
+                 identifiers: Optional[IdentifierList] = None,
+                 names: Optional[List[TextValue]] = None,
                  type: Optional[str] = None,
                  place: Optional[URI] = None,
                  jurisdiction: Optional["Resource | PlaceDescription"] = None, # PlaceDescription
@@ -35,6 +36,7 @@ class PlaceDescription(Subject):
                  longitude: Optional[float] = None,
                  temporalDescription: Optional[Date] = None,
                  spatialDescription: Optional[Resource] = None,) -> None:
+        
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
         self.names = names
         self.type = type
@@ -47,8 +49,8 @@ class PlaceDescription(Subject):
 
     @property
     def _as_dict_(self):
-        place_description_dict = super()._as_dict_
-        place_description_dict.update({
+        type_as_dict = super()._as_dict_
+        type_as_dict.update({
             "names": [n for n in self.names] if self.names else None,
             "type": self.type if self.type else None,
             "place": self.place._as_dict_ if self.place else None,
@@ -56,6 +58,13 @@ class PlaceDescription(Subject):
             "latitude": float(self.latitide) if self.latitide else None,
             "longitude": float(self.longitute) if self.longitute else None,
             "temporalDescription": self.temporalDescription if self.temporalDescription else None,
-            "spatialDescription": self.spacialDescription._as_dict_ if self.temporalDescription else None            
+            "spatialDescription": self.spacialDescription._as_dict_ if self.spacialDescription else None            
         })
-        return Serialization.serialize_dict(place_description_dict)    
+        return Serialization.serialize_dict(type_as_dict) 
+
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a PlaceDescription instance from a JSON-dict (already parsed).
+        """
+        return Serialization.deserialize(data, PlaceDescription)   

gedcomx/PlaceReference.py

@@ -7,27 +7,24 @@ class PlaceReference:
     identifier = 'http://gedcomx.org/v1/PlaceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
     
-    def __init__(self, original: Optional[str], descriptionRef: Optional[Resource]) -> None:
+    def __init__(self,
+                 original: Optional[str] = None,
+                 description: Optional[Resource] = None) -> None:
         self.original = original
-        self.descriptionRef = descriptionRef
+        self.description = description
 
     @property
     def _as_dict_(self):
-        place_reference_dict = {
+        type_as_dict = {
             'original': self.original,
-            'descriptionRef': self.descriptionRef._as_dict_ if isinstance(self.descriptionRef,Resource) else Resource(target=self.descriptionRef)._as_dict_
+            'description': self.description._as_dict_ if self.description else None
             } 
-        return Serialization.serialize_dict(place_reference_dict)
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data):
+        
+        return Serialization.deserialize(data, PlaceReference)
 
-def ensure_list(val):
-    if val is None:
-        return []
-    return val if isinstance(val, list) else [val]
 
-# PlaceReference
-PlaceReference._from_json_ = classmethod(lambda cls, data: PlaceReference(
-    original=data.get('original'),
-    descriptionRef=Resource._from_json_(data['description']) if data.get('description') else None
-))
 
-   

gedcomx/Relationship.py

@@ -35,12 +35,15 @@ class Relationship(Subject):
         person2 (Person): Second Person in Relationship
 
     Raises:
-        ValueError: If `id` is not a valid UUID.
+        
     """
     identifier = 'http://gedcomx.org/v1/Relationship'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, 
+    def __init__(self,
+             person1: Optional[Person | Resource] = None,
+             person2: Optional[Person | Resource] = None,
+             facts: Optional[List[Fact]] = None,  
              id: Optional[str] = None,
              lang: Optional[str] = None,
              sources: Optional[List[SourceReference]] = None,
@@ -53,74 +56,40 @@ class Relationship(Subject):
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[List[Identifier]] = None,
              type: Optional[RelationshipType] = None,
-             person1: Optional[Person | Resource] = None,
-             person2: Optional[Person | Resource] = None,
-             facts: Optional[List[Fact]] = None) -> None:
+             ) -> None:
     
         # Call superclass initializer if required
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
         
-        # Initialize optional parameters with default empty lists if None
-        #self.sources = sources if sources is not None else []
-        #self.notes = notes if notes is not None else []
-        #self.evidence = evidence if evidence is not None else []
-        #self.media = media if media is not None else []
-        #self.identifiers = identifiers if identifiers is not None else []
-        #self.facts = facts if facts is not None else []
-
-        # Initialize other attributes
         self.type = type
         self.person1 = person1
         self.person2 = person2
-        self.facts = facts if facts else None
+        self.facts = facts if facts else []
     
+    def add_fact(self,fact: Fact):
+        if fact is not None and isinstance(fact,Fact):
+            for existing_fact in self.facts:
+                if fact == existing_fact:
+                    return
+            self.facts.append(fact)
+        else:
+            raise TypeError(f"Expected type 'Fact' recieved type {type(fact)}")
+
     @property
     def _as_dict_(self):
-        return serialize_to_dict(self, {
+        type_as_dict = super()._as_dict_
+        type_as_dict.update({
             "type": self.type.value if isinstance(self.type, RelationshipType) else self.type,
-            "person1": self.person1.uri,
-            "person2": self.person2.uri,
+            "person1": self.person1._as_dict_ if self.person1 else None,
+            "person2": self.person2._as_dict_ if self.person2 else None,
             "facts": [fact for fact in self.facts] if self.facts else None
         })
+        return Serialization.serialize_dict(type_as_dict)
 
     @classmethod
     def _from_json_(cls, data: dict):
         """
-        Create a Relationship instance from a JSON-dict (already parsed).
+        Create a Person instance from a JSON-dict (already parsed).
         """
-        def ensure_list(value):
-            if value is None:
-                return []
-            if isinstance(value, list):
-                return value
-            return [value]  # wrap single item in list
-
-        # Basic scalar fields (adjust as needed)
-        id_        = data.get('id')
-        type_      = data.get('type')
-        extracted  = data.get('extracted', None)
-        private    = data.get('private', None)
-
-        # Complex singletons (adjust as needed)
-        person1    = Resource.from_url(data.get('person1')['resource']) if data.get('person1') else None
-        person2    = Resource.from_url(data.get('person2')['resource']) if data.get('person2') else None
-        facts      = [Fact._from_json_(o) for o in ensure_list(data.get('facts'))]
-        sources    = [SourceReference._from_json_(o) for o in ensure_list(data.get('sources'))]
-        notes      = [Note._from_json_(o) for o in ensure_list(data.get('notes'))]
-
-        # Build the instance
-        inst = cls(
-            id        = id_,
-            type      = type_,
-            extracted = extracted,
-            #private   = private,       #TODO Has this been added?
-            person1   = person1,
-            person2   = person2,
-            facts     = facts,
-            sources   = sources,
-            notes     = notes
-        )
-
-        return inst
-
+        return Serialization.deserialize(data, Relationship)
     

gedcomx/Resource.py

@@ -1,5 +1,6 @@
 from typing import List, Optional
 
+
 from .URI import URI
     
 class Resource:
@@ -16,7 +17,7 @@ class Resource:
     """
     def __init__(self,uri: Optional[URI|str] = None, id:Optional[str] = None,top_lvl_object: Optional[object] = None,target= None) -> None:
         
-        self.resource = URI.from_url(uri.value)
+        self.resource = URI.from_url(uri.value) if isinstance(uri,URI) else URI.from_url(uri) if isinstance(uri,str) else None
         self.Id = id
 
         self.type = None
@@ -31,9 +32,23 @@ class Resource:
    
     @property
     def _as_dict_(self):
-        return {'resource':self.resource.value,
+        from .Serialization import Serialization
+        typ_as_dict = {'resource':self.resource.value if self.resource else None,
                 'resourceId':self.Id}
+        return Serialization.serialize_dict(typ_as_dict)
+    
+    @classmethod
+    def _from_json_(cls,data):
+        # TODO This is not used but taken care of in Serialization
+        r = Resource(uri=data.get('resource'),id=data.get('resourceId',None))
+        #return r
 
+    def __repr__(self) -> str:
+        return f"Resource(uri={self.resource}, id={self.Id}, target={self.target})"
+    
+    def __str__(self) -> str:
+        return f"{self.resource}{f', id={self.Id}' if self.Id else ''}"
+    
 def get_resource_as_dict(value):
     """
     If value is truthy:
@@ -58,4 +73,3 @@ def get_resource_as_dict(value):
         print((f"value: {value} as inproper attributes"))
         exit()
 
-    

gedcomx/Serialization.py

@@ -1,42 +1,25 @@
 from typing import Dict
 
+from .Logging import get_logger
+
+log = get_logger(__name__)
+log.setLevel("DEBUG")
+log.info("Logger initialized.")
+
 from collections.abc import Sized
+from typing import Any, get_origin, get_args, List, Set, Tuple, Dict, Union, ForwardRef, Annotated
+import types
+
+import enum
+from .Resource import Resource
+from .Identifier import IdentifierList
+from .URI import URI
 
+_PRIMITIVES = (str, int, float, bool, type(None))
 
 def _has_parent_class(obj) -> bool:
     return hasattr(obj, '__class__') and hasattr(obj.__class__, '__bases__') and len(obj.__class__.__bases__) > 0
 
-def serialize_to_dict(obj,class_values:Dict,ignore_null=True):
-    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
-
-    values_dict = {}
-    if _has_parent_class(obj):
-        values_dict.update(super(obj.__class__, obj)._as_dict_)
-    if class_values:
-        values_dict.update(class_values)
-        # Serialize and exclude None values
-
-    empty_fields = []
-    for key, value in values_dict.items():
-        if value is not None:
-            values_dict[key] = _serialize(value)
-        else:
-            empty_fields.append(key)
-    
-    for key in empty_fields:
-            del values_dict[key]
-                
-    return values_dict
 
 class Serialization:
 
@@ -78,3 +61,341 @@ class Serialization:
                     if v is not None and not (isinstance(v, Sized) and len(v) == 0)
                 }
         return {}
+   
+    @staticmethod
+    def _coerce_value(value: Any, typ: Any) -> Any:
+        """Coerce `value` to `typ`:
+        - primitives: pass through
+        - containers: recurse into elements
+        - objects: call typ._from_json_(dict) if available and value is dict
+        - already-instantiated objects of typ: pass through
+        - otherwise: return value unchanged
+        """
+        def is_enum_type(T) -> bool:
+            """Return True if T (possibly a typing construct) is or contains an Enum type."""
+            origin = get_origin(T)
+
+            # Unwrap Union/Optional/PEP 604 (A | B)
+            if origin in (Union, types.UnionType):
+                return any(is_enum_type(a) for a in get_args(T))
+
+            # Unwrap Annotated[T, ...]
+            if origin is Annotated:
+                return is_enum_type(get_args(T)[0])
+
+            # Resolve forward refs / strings if you use them
+            if isinstance(T, ForwardRef):
+                T = globals().get(T.__forward_arg__, T)
+            if isinstance(T, str):
+                T = globals().get(T, T)
+
+            # Finally check enum-ness
+            try:
+                return issubclass(T, enum.Enum)
+            except TypeError:
+                return False  # not a class (e.g., typing.List[int], etc.)
+        log.debug(f"Coercing value '{value}' of type '{type(value).__name__}' to '{typ}'")
+
+        def _resolve(t):
+            # resolve ForwardRef('Resource') -> actual object if already in globals()
+            if isinstance(t, ForwardRef):
+                return globals().get(t.__forward_arg__, t)
+            return t
+
+        if is_enum_type(typ):
+            log.debug(f"Enum type detected: {typ}")
+            return typ(value)  # cast to enum
+        
+        origin = get_origin(typ)
+        if origin in (Union, types.UnionType):
+            args = tuple(_resolve(a) for a in get_args(typ))
+        else:
+            args = (_resolve(typ),)
+        log.debug(f"Origin: {origin}, args: {args}")
+        
+        if Resource in args and isinstance(value, dict):
+            if Resource in args:
+                log.info(f"Deserializing Resource from value: {value}")
+                return Resource(uri=value.get('resource'), id=value.get('resourceId', None))
+
+        if isinstance(value, _PRIMITIVES):
+            if Resource in args:
+                log.info(f"Deserializing Resource from value: {value}")
+                return Resource(uri=value)
+            if URI in args:
+                log.info(f"Deserializing URI from value: {value}")
+                return URI.from_url(value)
+            return value
+        
+        if IdentifierList in args:
+                log.error(f"Deserializing IdentifierList from value: {value}")
+                return IdentifierList._from_json_(value)
+  
+        if origin in (list, List):
+            elem_args = get_args(typ)          # NOT get_args(args)
+            elem_t = elem_args[0] if elem_args else Any
+            log.debug(f"List: {typ}, elem={elem_t}")
+            return [Serialization._coerce_value(v, elem_t) for v in (value or [])]
+
+        if origin in (set, Set):
+            (elem_t,) = args or (Any,)
+            return { Serialization._coerce_value(v, elem_t) for v in (value or []) }
+
+        if origin in (tuple, Tuple):
+            if not args:
+                return tuple(value)
+            if len(args) == 2 and args[1] is Ellipsis:  # Tuple[T, ...]
+                elem_t = args[0]
+                return tuple(Serialization._coerce_value(v, elem_t) for v in (value or []))
+            return tuple(Serialization._coerce_value(v, t) for v, t in zip(value, args))
+
+        if origin in (dict, Dict):
+            k_t, v_t = args or (Any, Any)
+            return {
+                Serialization._coerce_value(k, k_t): Serialization._coerce_value(v, v_t)
+                for k, v in (value or {}).items()
+            }
+
+        # If `typ` has _from_json_ and value is a dict, use it
+        if hasattr(typ, "_from_json_") and isinstance(value, dict):
+            log.info(f"Deserializing {typ} from json method with value: {value}")
+            return typ._from_json_(value)
+
+        # If already the right type, keep it
+        try:
+            if isinstance(value, typ):
+                return value
+        except TypeError:
+            log.debug(f"Could not coerce value '{value}' to type '{typ}'")
+            pass  # `typ` may be a typing construct not valid for isinstance
+
+        # Fallback: leave as-is
+        log.debug(f"Returning '{type(value)}' type")
+        return value
+
+    @staticmethod
+    def get_class_fields(cls_name) -> Dict:
+        from typing import List, Optional
+        from gedcomx.Attribution import Attribution
+        from gedcomx.Document import Document  , DocumentType, TextType 
+        from gedcomx.Note import Note
+        from gedcomx.Resource import Resource
+        from gedcomx.SourceReference import SourceReference
+        from gedcomx.extensions.rs10.rsLink import _rsLinkList
+        from gedcomx.Conclusion import ConfidenceLevel
+        from gedcomx.EvidenceReference import EvidenceReference
+        from gedcomx.Identifier import IdentifierList
+        from gedcomx.Gender import  Gender, GenderType
+        from gedcomx.Fact import Fact
+        from gedcomx.Name import Name  
+        from gedcomx.URI import URI
+        from gedcomx.Qualifier import Qualifier 
+        from gedcomx.PlaceDescription import PlaceDescription
+        from gedcomx.PlaceReference import PlaceReference   
+        from gedcomx.Person import Person
+        from gedcomx.Relationship import Relationship, RelationshipType
+        from gedcomx.Identifier import Identifier   
+        from gedcomx.Date import Date
+        from gedcomx.TextValue import TextValue
+        from gedcomx.Address import Address
+        from gedcomx.OnlineAccount import OnlineAccount
+        from gedcomx.Event import Event, EventType, EventRole
+        from .SourceDescription import SourceDescription
+
+        fields = { 'Conclusion' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List["SourceReference"],
+                                    "analysis": Document | Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "uri": "Resource",
+                                    "max_note_count": int,
+                                    "links": _rsLinkList
+                                    },
+                    'Subject' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List["SourceReference"],
+                                    "analysis": Resource,
+                                    "notes": List["Note"],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "uri": Resource,
+                                    "links": _rsLinkList
+                                },
+                    'Person' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "private": bool,
+                                    "gender": Gender,
+                                    "names": List[Name],
+                                    "facts": List[Fact],
+                                    "living": bool,
+                                    "links": _rsLinkList,
+                                    'uri': Resource
+                                },
+                    'SourceReference' : {
+                                    "description": SourceDescription | URI | Resource,
+                                    "descriptionId": str,
+                                    "attribution": Attribution,
+                                    "qualifiers": List[Qualifier],
+},
+                    'Attribution' : {
+                                    "contributor": Resource | Attribution,
+                                    "modified": str,
+                                    "changeMessage": str,
+                                    "creator": Resource | Attribution,
+                                    "created": str  
+        },
+                    'Gender' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "type": GenderType,
+                                                    },
+                    'PlaceReference' : {
+                                    "original": str,
+                                    "description": PlaceDescription | URI,
+                                    },
+                    'Relationship' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Document | Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": IdentifierList,
+                                    "type": RelationshipType,
+                                    "person1": Person | Resource,
+                                    "person2": Person | Resource,
+                                    "facts": List[Fact],
+},
+                    'Document' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "type": DocumentType,
+                                    "extracted": bool,
+                                    "textType": TextType,
+                                    "text": str,
+                                },
+                    'PlaceDescription' : {
+                                    "id": str,
+                                    "lang": str,
+                                    "sources": List[SourceReference],
+                                    "analysis": Resource,
+                                    "notes": List[Note],
+                                    "confidence": ConfidenceLevel,
+                                    "attribution": Attribution,
+                                    "extracted": bool,
+                                    "evidence": List[EvidenceReference],
+                                    "media": List[SourceReference],
+                                    "identifiers": List[IdentifierList],
+                                    "names": List[TextValue],
+                                    "type": str,
+                                    "place": URI,
+                                    "jurisdiction": Resource | PlaceDescription,
+                                    "latitude": float,
+                                    "longitude": float,
+                                    "temporalDescription": Date,
+                                    "spatialDescription": Resource,
+                                },
+                    "Agent" : {
+    "id": str,
+    "identifiers": IdentifierList,
+    "names": List[TextValue],
+    "homepage": URI,
+    "openid": URI,
+    "accounts": List[OnlineAccount],
+    "emails": List[URI],
+    "phones": List[URI],
+    "addresses": List[Address],
+    "person": object | Resource,  # intended to be Person | Resource
+    # "xnotes": List[Note],  # commented out in your __init__
+    "attribution": object,  # for GEDCOM5/7 compatibility
+    "uri": URI | Resource,
+},
+'Event' : {
+    "id": str,
+    "lang": str,
+    "sources": List[SourceReference],
+    "analysis": Resource,
+    "notes": List[Note],
+    "confidence": ConfidenceLevel,
+    "attribution": Attribution,
+    "extracted": bool,
+    "evidence": List[EvidenceReference],
+    "media": List[SourceReference],
+    "identifiers": List[Identifier],
+    "type": EventType,
+    "date": Date,
+    "place": PlaceReference,
+    "roles": List[EventRole],
+}
+
+}
+        
+        
+        return fields[cls_name] if cls_name in fields else {}
+
+    @staticmethod
+    def deserialize(data: dict[str, Any], class_type) -> Any:
+        """
+        Deserialize `data` according to `fields` (field -> type).
+        - Primitives are assigned directly.
+        - Objects use `type._from_json_(dict)` when present.
+        - Lists/Sets/Tuples/Dicts are recursively processed.
+        Returns (result, unknown_keys).
+        """
+        log.debug(f"Deserializing '{data}' into '{class_type.__name__}'")
+        class_fields = Serialization.get_class_fields(str(class_type.__name__))
+        if class_fields == {}:
+            log.warning(f"No class fields found for '{class_type.__name__}'")
+        log.debug(f"class fields: {class_fields}")
+        result: dict[str, Any] = {}
+        known = set(class_fields.keys())
+        log.debug(f"keys found in JSON: {data.keys()}")
+        #log.debug(f"known fields: {known}")
+        for name, typ in class_fields.items():
+            if name in data:
+                log.debug(f"Field '{name}' of {class_type.__name__} found in data")
+                result[name] = Serialization._coerce_value(data[name], typ)
+                #if type(result[name]) != class_fields[name]:# TODO Write better type checking 
+                #    log.error(f"Field '{name}' of {class_type.__name__} was expected to be of type '{class_fields[name]}', but got '{type(result[name])}' with value '{result[name]}'")
+                #    raise TypeError(f"Field '{name}' expected type '{class_fields[name]}', got '{type(result[name])}'")
+                log.debug(f"Field '{name}' of '{class_type.__name__}' resulted in a '{type(result[name]).__name__}' with value '{result[name]}'")
+            else:
+                log.debug(f"Field '{name}' of '{class_type.__name__}' not found in JSON data")
+
+        unknown_keys = [k for k in data.keys() if k not in known]
+        log.info(f"Creating instance of {class_type.__name__} with fields: {result.keys()}")
+        new_cls = class_type(**result)
+        log.debug(f"Deserialized {class_type.__name__} with unknown keys: {unknown_keys}")
+        return new_cls  # type: ignore, unknown_keys