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

gedcomx/Conclusion.py

@@ -5,26 +5,113 @@ import warnings
 from typing import List, Optional
 
 from .Attribution import Attribution
+#from .Document import Document
 from .Note import Note
 from .Qualifier import Qualifier
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource, URI
+from .Extensions.rs10.rsLink import _rsLinkList, rsLink
+
+from collections.abc import Sized
 
 class ConfidenceLevel(Qualifier):
     High = "http://gedcomx.org/High"
     Medium = "http://gedcomx.org/Medium"
     Low = "http://gedcomx.org/Low"
-    
+
+    _NAME_TO_URI = {
+        "high": High,
+        "medium": Medium,
+        "low": Low,
+    }
+
+    @classmethod
+    def _from_json_(cls, data):
+        """
+        Accepts:
+          - "High" | "Medium" | "Low"
+          - "http://gedcomx.org/High" | ".../Medium" | ".../Low"
+          - {"type": "..."} or {"value": "..."} or {"confidence": "..."} or {"level": "..."} or {"uri": "..."}
+          - existing ConfidenceLevel instance
+        Returns:
+          ConfidenceLevel instance with .value set to the canonical URI.
+        """
+        if data is None:
+            return None
+
+        if isinstance(data, cls):
+            return data
+
+        # Extract token from dicts or use the raw scalar
+        if isinstance(data, dict):
+            token = (
+                data.get("confidence")
+                or data.get("type")
+                or data.get("value")
+                or data.get("level")
+                or data.get("uri")
+            )
+        else:
+            token = data
+
+        if token is None:
+            return None
+
+        token_str = str(token).strip()
+
+        # Normalize to canonical URI
+        if token_str.lower() in cls._NAME_TO_URI:
+            uri = cls._NAME_TO_URI[token_str.lower()]
+        elif token_str in (cls.High, cls.Medium, cls.Low):
+            uri = token_str
+        else:
+            raise ValueError(f"Unknown ConfidenceLevel: {token!r}")
+
+        # Create a ConfidenceLevel instance without invoking Qualifier.__init__
+        obj = cls.__new__(cls)
+        # store the canonical URI on the instance; used by description and (optionally) serialization
+        obj.value = uri
+        return obj
+
     @property
     def description(self):
         descriptions = {
-            ConfidenceLevel.High: "The contributor has a high degree of confidence that the assertion is true.",
-            ConfidenceLevel.Medium: "The contributor has a medium degree of confidence that the assertion is true.",
-            ConfidenceLevel.Low: "The contributor has a low degree of confidence that the assertion is true."
+            self.High: "The contributor has a high degree of confidence that the assertion is true.",
+            self.Medium: "The contributor has a medium degree of confidence that the assertion is true.",
+            self.Low: "The contributor has a low degree of confidence that the assertion is true."
         }
-        return descriptions.get(self, "No description available.")
+        # Works whether the instance holds .value or (edge-case) if `self` is compared directly
+        key = getattr(self, "value", self)
+        return descriptions.get(key, "No description available.")
+
     
 class Conclusion:
+    """
+    Represents a conclusion in the GEDCOM X conceptual model. A conclusion is a 
+    genealogical assertion about a person, relationship, or event, derived from 
+    one or more sources, with optional supporting metadata such as confidence, 
+    attribution, and notes.
+
+    Args:
+        id (str, optional): A unique identifier for the conclusion. If not provided, 
+            a UUID-based identifier will be automatically generated.
+        lang (str, optional): The language code of the conclusion. Defaults to 'en'.
+        sources (list[SourceReference], optional): A list of source references that 
+            support the conclusion.
+        analysis (Document | Resource, optional): A reference to an analysis document 
+            or resource that supports the conclusion.
+        notes (list[Note], optional): A list of notes providing additional context. 
+            Defaults to an empty list.
+        confidence (ConfidenceLevel, optional): The contributor's confidence in the 
+            conclusion (High, Medium, or Low).
+        attribution (Attribution, optional): Information about who contributed the 
+            conclusion and when.
+        uri (Resource, optional): A URI reference for the conclusion. Defaults to a 
+            URI with the fragment set to the `id`.
+        links (_LinkList, optional): A list of links associated with the conclusion. 
+            Defaults to an empty `_LinkList`.  
+    """
     identifier = 'http://gedcomx.org/v1/Conclusion'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -39,30 +126,32 @@ class Conclusion:
         return short_uuid
     
     def __init__(self,
-                 id: Optional[str],
+                 id: Optional[str] = None,
                  lang: Optional[str] = 'en',
-                 sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
-                 notes: Optional[List[Note]] = [],
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[object | Resource] = None,
+                 notes: Optional[List[Note]] = None,
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
-                 uri: Optional[URI] = None,
-                 max_note_count: int = 20) -> None:
+                 uri: Optional[Resource] = None,
+                 _max_note_count: int = 20,
+                 links: Optional[_rsLinkList] = None) -> None:
         
         self._id_generator = Conclusion.default_id_generator
 
-        self.id = id if id else self._id_generator()
+        self.id = id if id else None
         self.lang = lang
-        self.sources = sources
+        self.sources = sources if sources else []
         self.analysis = analysis
-        self.notes = notes
+        self.notes = notes if notes else []
         self.confidence = confidence
         self.attribution = attribution
-        self.max_note_count = max_note_count
-        self._uri = uri if uri else URI(fragment=id)
+        self.max_note_count = _max_note_count
+        self.uri = uri if uri else URI(fragment=id if id else self.id)
+        self.links = links if links else _rsLinkList()    #NOTE This is not in specification, following FS format
     
     def add_note(self,note_to_add: Note):
-        if len(self.notes) >= self.max_note_count:
+        if self.notes and len(self.notes) >= self.max_note_count:
             warnings.warn(f"Max not count of {self.max_note_count} reached for id: {self.id}")
             return False
         if note_to_add and isinstance(note_to_add,Note):
@@ -79,48 +168,38 @@ class Conclusion:
             self.sources.append(source_to_add)
         else:
             raise ValueError()
-    
-    '''
-    def _as_dict_(self):
-        return {
-            'id':self.id,
-            'lang':self.lang,
-            'sources': [source._prop_dict() for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
-            'notes':"Add notes here",
-            'confidence':self.confidence
-        }
-    '''
+        
+    def add_link(self,link: rsLink) -> bool:
+        """
+        Adds a link to the Conclusion link list.
+
+        Args:
+            link (rsLink): The link to be added.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        
+        Note: Duplicate checking not impimented at this level
+        """
+        if link and isinstance(link,rsLink):
+            self.links.add(link)
+            return True
+        return False
     
     @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
-
-        # Only add Relationship-specific fields
-        conclusion_fields = {
+        type_as_dict = {
             'id':self.id,
             'lang':self.lang,
-            'sources': [source for source in self.sources] if self.sources else None,
-            'analysis': self.analysis._uri if self.analysis else None,
+            'sources': [source._as_dict_ for source in self.sources] if self.sources else None,
+            'analysis': self.analysis if self.analysis else None,
             'notes': [note for note in self.notes] if self.notes else None,
-            'confidence':self.confidence
+            'confidence':self.confidence,
+            'attribution':self.attribution,
+            'links':self.links._as_dict_ if self.links else None
         }
-
-        # Serialize and exclude None values
-        for key, value in conclusion_fields.items():
-            if value is not None:
-                                conclusion_fields[key] = _serialize(value)
-        return conclusion_fields
+      
+        return Serialization.serialize_dict(type_as_dict) 
     
     def __eq__(self, other):
         if not isinstance(other, self.__class__):

gedcomx/Coverage.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 from .Date import Date
 from .PlaceReference import PlaceReference
+from .Serialization import Serialization
 
 class Coverage:
     identifier = 'http://gedcomx.org/v1/Coverage'
@@ -13,6 +14,15 @@ class Coverage:
     
     # ...existing code...
 
+    @property
+    def _as_dict_(self):
+        type_as_dict = {
+            'spatial': self.spatial if self.spatial else None,
+            'temporal': self. temporal if self.temporal else None
+        }
+
+        return Serialization.serialize_dict(type_as_dict) 
+
     @classmethod
     def _from_json_(cls, data: dict):
         """

gedcomx/Date.py

@@ -1,29 +1,65 @@
 from typing import Optional
+from datetime import datetime, timezone
+from dateutil import parser
+import time
 
 
 class DateFormat:
     def __init__(self) -> None:
         pass
-        
+
+class DateNormalization():
+    pass        
 
 class Date:
     identifier = 'http://gedcomx.org/v1/Date'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, original: Optional[str],formal: Optional[str | DateFormat] = None) -> None:
+    def __init__(self, original: Optional[str],normalized: Optional[DateNormalization] = None ,formal: Optional[str | DateFormat] = None) -> None:
         self.orginal = original
         self.formal = formal
+
+        self.normalized: DateNormalization | None = normalized if normalized else None
     
-    def _prop_dict(self):
+    @property
+    def _as_dict_(self):
         return {'original': self.orginal,
                 'formal': self.formal}
 
-# Date
-Date._from_json_ = classmethod(lambda cls, data: Date(
-    original=data.get('original'),
-    formal=data.get('formal')
-))
+    @classmethod
+    def _from_json_(obj,data):
+        original = data.get('original',None)
+        formal = data.get('formal',None)
+        
+        return Date(original=original,formal=formal)
+        
+
+
+def date_to_timestamp(date_str: str, assume_utc_if_naive: bool = True, print_definition: bool = True):
+    """
+    Convert a date string of various formats into a Unix timestamp.
 
-Date._to_dict_ = lambda self: {
-    'original': self.orginal,
-    'formal': self.formal}    
+    A "timestamp" refers to an instance of time, including values for year, 
+    month, date, hour, minute, second, and timezone.
+    """
+    # Handle year ranges like "1894-1912" → pick first year
+    if "-" in date_str and date_str.count("-") == 1 and all(part.isdigit() for part in date_str.split("-")):
+        date_str = date_str.split("-")[0].strip()
+
+    # Parse date
+    dt = parser.parse(date_str)
+
+    # Ensure timezone awareness
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc if assume_utc_if_naive else datetime.now().astimezone().tzinfo)
+
+    # Normalize to UTC and compute timestamp
+    dt_utc = dt.astimezone(timezone.utc)
+    epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
+    ts = (dt_utc - epoch).total_seconds()
+
+    # Create ISO 8601 string with full date/time/timezone
+    full_timestamp_str = dt_utc.replace(microsecond=0).isoformat()
+
+    
+    return ts, full_timestamp_str

gedcomx/Document.py

@@ -1,13 +1,13 @@
 from enum import Enum
-from typing import Optional
+from typing import Optional, List
 
-from gedcomx.Attribution import Attribution
-from gedcomx.Conclusion import ConfidenceLevel
-from gedcomx.Note import Note
-from gedcomx.SourceReference import SourceReference
-from gedcomx.URI import URI
+from .Attribution import Attribution
+from .Note import Note
+from .SourceReference import SourceReference
+from .Resource import Resource
 
 from .Conclusion import Conclusion
+from .Serialization import Serialization
 
 class DocumentType(Enum):
     Abstract = "http://gedcomx.org/Abstract"
@@ -33,10 +33,41 @@ class Document(Conclusion):
     identifier = 'http://gedcomx.org/v1/Document'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, id: str | None, lang: str | None, sources: SourceReference | None, analysis: URI | None, notes: Note | None, confidence: ConfidenceLevel | None, attribution: Attribution | None,
-                 type: Optional[DocumentType],
-                 extracted: Optional[bool], # Default to False
-                 textType: Optional[TextType],
-                 text: str,
+    def __init__(self, id: Optional[str] = None,
+                 lang: Optional[str] = None,
+                 sources: Optional[List[SourceReference]] = None,
+                 analysis: Optional[Resource] = None,
+                 notes: Optional[List[Note]] = None,
+                 confidence: Optional[object] = None, # ConfidenceLevel
+                 attribution: Optional[Attribution] = None,
+                 type: Optional[DocumentType] = None,
+                 extracted: Optional[bool] = None, # Default to False
+                 textType: Optional[TextType] = None,
+                 text: Optional[str] = None,
                  ) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+        self.type = type
+        self.extracted = extracted
+        self.textType = textType
+        self.text = text
+    
+    @property
+    def _as_dict(self):
+        type_as_dict = super()._as_dict_
+        if self.type:
+            type_as_dict['type'] = self.type.value
+        if self.extracted is not None:
+            type_as_dict['extracted'] = self.extracted
+        if self.textType:
+            type_as_dict['textType'] = self.textType.value
+        if self.text:
+            type_as_dict['text'] = self.text
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        type_as_dict = Serialization.get_class_fields('Document')
+        return Serialization.deserialize(data, type_as_dict)

gedcomx/Event.py

@@ -9,9 +9,10 @@ from .Conclusion import Conclusion, ConfidenceLevel
 from .Date import Date
 from .Note import Note
 from .PlaceReference import PlaceReference
+from .Serialization import Serialization
 from .SourceReference import SourceReference
 from .Subject import Subject
-from .URI import URI
+from .Resource import Resource
 
 class EventRoleType(Enum):
     Principal = "http://gedcomx.org/Principal"
@@ -37,11 +38,11 @@ class EventRole(Conclusion):
                  id: Optional[str] = None,
                  lang: Optional[str] = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
-                 person: URI = None,
+                 person: Resource = None,
                  type: Optional[EventRoleType] = None,
                  details: Optional[str] = None) -> None:
         super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
@@ -84,6 +85,7 @@ class EventType(Enum):
     Naturalization = "http://gedcomx.org/Naturalization"
     Ordination = "http://gedcomx.org/Ordination"
     Retirement = "http://gedcomx.org/Retirement"
+    MarriageSettlment = 'https://gedcom.io/terms/v7/MARS'
     
     @property
     def description(self):
@@ -180,7 +182,7 @@ class Event(Subject):
                  id: Optional[str] = None,
                  lang: Optional[str] = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
@@ -192,4 +194,21 @@ class Event(Subject):
                  date: Optional[Date] = None,
                  place: Optional[PlaceReference] = None,
                  roles: Optional[List[EventRole]] = []) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, extracted, evidence, media, identifiers)
+
+        self.type = type if type and isinstance(type, EventType) else None
+        self.date = date if date and isinstance(date, Date) else None               
+        self.place = place if place and isinstance(place, PlaceReference) else None
+        self.roles = roles if roles and isinstance(roles, list) else []
+    
+    @property
+    def _as_dict_(self):
+        raise NotImplementedError("Not implemented yet")
+    
+    @classmethod
+    def _from_json_(cls, data: dict):
+        """
+        Create a Person instance from a JSON-dict (already parsed).
+        """
+        type_as_dict = Serialization.get_class_fields('Event')
+        return Serialization.deserialize(data, type_as_dict)

gedcomx/EvidenceReference.py

@@ -1,11 +1,11 @@
 from typing import Optional
 
 from .Attribution import Attribution
-from .URI import URI
+from .Resource import Resource
 
 class EvidenceReference:
     identifier = 'http://gedcomx.org/v1/EvidenceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, resource: URI, attribution: Optional[Attribution]) -> None:
+    def __init__(self, resource: Resource, attribution: Optional[Attribution]) -> None:
         pass

gedcomx/Exceptions.py

@@ -0,0 +1,16 @@
+
+
+class GedcomXError(Exception):
+    """Base for all app-specific errors."""
+
+class GedcomClassAttributeError(GedcomXError):
+    def __init__(self, *args: object) -> None:
+        msg = f"This class need more information to be created: {args}"
+        super().__init__(msg)
+
+
+class TagConversionError(GedcomXError):
+    def __init__(self, record,levelstack):
+        msg = f"Cannot convert: #{record.line} TAG: {record.tag} {record.xref if record.xref else ''} Value:{record.value} STACK: {type(levelstack[record.level-1]).__name__}"
+        super().__init__(msg)
+        

gedcomx/Fact.py

@@ -3,21 +3,27 @@ import re
 
 from datetime import datetime
 from enum import Enum
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
+from .Document import Document
 from .Date import Date
 from .Note import Note
 from .PlaceReference import PlaceReference
 from .SourceReference import SourceReference
-from .URI import URI
+from .Serialization import Serialization
+from .Resource import Resource
 
 from .Conclusion import Conclusion
 from .Qualifier import Qualifier
 
 from enum import Enum
 
+from collections.abc import Sized
+
+from .Extensions.rs10.rsLink import rsLink, _rsLinkList
+
 
 class FactType(Enum):
     # Person Fact Types
@@ -390,73 +396,90 @@ class Fact(Conclusion):
     version = 'http://gedcomx.org/conceptual-model/v1'
 
     def __init__(self,
-                 id: str = None,
+                 id: Optional[str] = None,
                  lang: str = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: URI = None,
+                 analysis: Optional[Resource | Document] = None,
                  notes: Optional[List[Note]] = [],
-                 confidence: ConfidenceLevel = None,
-                 attribution: Attribution = None,
-                 type: FactType = None,
+                 confidence: Optional[ConfidenceLevel] = None,
+                 attribution: Optional[Attribution] = None,
+                 type: Optional[FactType] = None,
                  date: Optional[Date] = None,
                  place: Optional[PlaceReference] = None,
                  value: Optional[str] = None,
-                 qualifiers  = []) -> None:       #qualifiers: Optional[List[FactQualifier]] = []) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+                 qualifiers: Optional[List[FactQualifier]] = None,
+                 links: Optional[_rsLinkList] = None):
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution, links=links)
         self.type = type
         self.date = date
         self.place = place
         self.value = value
-        self.qualifiers = qualifiers
+        self._qualifiers = qualifiers if qualifiers else []
     
+
     @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("UKN " + value)  # fallback for unknown objects
+    def qualifiers(self) -> List[FactQualifier]:
+        return self._qualifiers # type: ignore
 
+    @qualifiers.setter
+    def qualifiers(self, value: List[FactQualifier]):
+        if (not isinstance(value, list)) or (not all(isinstance(item, FactQualifier) for item in value)):
+            raise ValueError("sources must be a list of GedcomRecord objects.")
+        self._qualifiers.extend(value)
+
+    @property
+    def _as_dict_(self):
+        fact_dict = super()._as_dict_
         # Only add Relationship-specific fields
-        fact_fields = {
+        fact_dict.update( {
             'type': self.type.value if self.type else None,
-            'date': self.date._prop_dict() if self.date else None,
+            'date': self.date._as_dict_ if self.date else None,
             'place': self.place._as_dict_ if self.place else None,
             'value': self.value,
             'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
-        }
+        })
+        
+        return Serialization.serialize_dict(fact_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: Dict[str, Any]) -> 'Fact':
+        
+        # Extract fields, no trailing commas!
+        id_          = data.get('id')
+        lang         = data.get('lang', 'en')
+        sources      = [SourceReference._from_json_(s) for s in data.get('sources',[])]
+        analysis     = (Resource._from_json_(data['analysis'])
+                        if data.get('analysis') else None)
+        notes        = [Note._from_json_(n) for n in data.get('notes',[])]
+        confidence   = (ConfidenceLevel._from_json_(data['confidence'])
+                        if data.get('confidence') else None)
+        attribution  = (Attribution._from_json_(data['attribution']) if data.get('attribution') else None)
+        fact_type    = (FactType.from_value(data['type'])
+                        if data.get('type') else None)
+        date         = (Date._from_json_(data['date'])
+                        if data.get('date') else None)
+        place        = (PlaceReference._from_json_(data['place'])
+                        if data.get('place') else None)
+        value        = data.get('value')
+        qualifiers   = [Qualifier._from_json_(q) for q in data.get('qualifiers', [])]
+        links = _rsLinkList._from_json_(data.get('links')) if data.get('links') else None
+
+        return cls(
+            id=id_,
+            lang=lang,
+            sources=sources,
+            analysis=analysis,
+            notes=notes,
+            confidence=confidence,
+            attribution=attribution,
+            type=fact_type,
+            date=date,
+            place=place,
+            value=value,
+            qualifiers=qualifiers,
+            links=links
+        )
 
-        # Serialize and exclude None values
-        for key, value in fact_fields.items():
-            if value is not None:
-                                fact_fields[key] = _serialize(value)
 
-        
-        return fact_fields
 
-def ensure_list(val):
-    if val is None:
-        return []
-    return val if isinstance(val, list) else [val]
-# Fact
-Fact._from_json_ = classmethod(lambda cls, data: cls(
-    id=data.get('id'),
-    lang=data.get('lang', 'en'),
-    sources=[SourceReference._from_json_(s) for s in ensure_list(data.get('sources'))],
-    analysis=URI._from_json_(data['analysis']) if data.get('analysis') else None,
-    notes=[Note._from_json_(n) for n in ensure_list(data.get('notes'))],
-    confidence=ConfidenceLevel._from_json_(data['confidence']) if data.get('confidence') else None,
-    attribution=Attribution._from_json_(data['attribution']) if data.get('attribution') else None,
-    type=FactType.from_value(data['type']) if data.get('type') else None,
-    date=Date._from_json_(data['date']) if data.get('date') else None,
-    place=PlaceReference._from_json_(data['place']) if data.get('place') else None,
-    value=data.get('value'),
-    qualifiers=[Qualifier._from_json_(q) for q in ensure_list(data.get('qualifiers'))]
-))