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

gedcomx/Name.py

@@ -2,13 +2,33 @@ from enum import Enum
 from typing import List,Optional
 from typing_extensions import Self
 
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    Name.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX Name, NameType, NameForm, NamePart Types
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
+#======================================================================
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
 from .Date import Date
 from .Note import Note
-from .Serialization import Serialization
-from .SourceReference import SourceReference
 from .Resource import Resource
+from .SourceReference import SourceReference
+#======================================================================
 
 
 class NameType(Enum):
@@ -90,22 +110,57 @@ class NamePartType(Enum):
         return descriptions.get(self, "No description available.")
     
 class NamePart:
+    """Used to model a portion of a full name
+        including the terms that make up that portion. Some name parts may have qualifiers
+        to provide additional semantic meaning to the name part (e.g., "given name" or "surname").
+
+    Args:
+        type (NamePartType | None): Classification of this component of the name
+            (e.g., ``Given``, ``Surname``, ``Prefix``, ``Suffix``, ``Title``, ``Particle``).
+        value (str): The textual value for this part, without surrounding
+            punctuation (e.g., ``"John"``, ``"van"``, ``"III"``).
+        qualifiers (list[NamePartQualifier] | None): Optional qualifiers that refine
+            the meaning or usage of this part (e.g., language/script variants, initials).
+
+    Examples:
+        >>> from gedcomx.Name import *
+        >>> typ = NamePartType.Given
+        >>> given = "Moses"
+        >>> q = NamePartQualifier.Primary
+        >>> name = NamePart(type=typ,value=given,qualifiers=[q])
+        >>> print(name)
+        NamePart(type=Given, value='Moses', qualifiers=1)
+
+    """
     identifier = 'http://gedcomx.org/v1/NamePart'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
     def __init__(self,
                  type: Optional[NamePartType] = None,
                  value: Optional[str] = None,
-                 qualifiers: Optional[List[NamePartQualifier]] = []) -> None:
+                 qualifiers: Optional[List[NamePartQualifier]] = None) -> None:
         self.type = type
         self.value = value
-        self.qualifiers = qualifiers
+        self.qualifiers = qualifiers if qualifiers else []
     
+    @property
     def _as_dict_(self):
-        return Serialization.serialize_dict(
-            {'type': self.type.value if self.type else None,
-             'value': self.value if self.value else None,
-             'qualifiers': [qualifier.value for qualifier in self.qualifiers] if self.qualifiers else None})
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.type:
+            type_as_dict['type'] = self.type.value
+        if self.value:
+            type_as_dict['value'] = self.value
+        if self.qualifiers:
+            type_as_dict['qualifiers'] = [q.value for q in self.qualifiers]
+        Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls,data):
+        name_part =NamePart(type=NamePartType(data['type']) if 'type' in data else None,
+                            value=data.get('value'),
+                            qualifiers=[NamePartQualifier(q) for q in data.get('qualifiers')])
+        return name_part
 
     def __eq__(self, other):
         if not isinstance(other, NamePart):
@@ -114,26 +169,114 @@ class NamePart:
                 self.value == other.value and
                 self.qualifiers == other.qualifiers)    
 
+    def __str__(self) -> str:
+        parts = []
+        if self.type is not None:
+            parts.append(f"type={getattr(self.type, 'name', str(self.type))}")
+        if self.value is not None:
+            parts.append(f"value={self.value!r}")
+        if self.qualifiers:
+            parts.append(f"qualifiers={len(self.qualifiers)}")
+        return f"NamePart({', '.join(parts)})" if parts else "NamePart()"
+
+    def __repr__(self) -> str:
+        if self.type is not None:
+            tcls = self.type.__class__.__name__
+            tname = getattr(self.type, "name", str(self.type))
+            tval = getattr(self.type, "value", self.type)
+            type_repr = f"<{tcls}.{tname}: {tval!r}>"
+        else:
+            type_repr = "None"
+        return (
+            f"{self.__class__.__name__}("
+            f"type={type_repr}, "
+            f"value={self.value!r}, "
+            f"qualifiers={self.qualifiers!r})"
+        )
+
 class NameForm:
+    """A representation of a name (a "name form") 
+        within a given cultural context, such as a given language and script.
+        As names are captured (both in records or in applications), the terms
+        in the name are sometimes classified by type. For example, a certificate
+        of death might prompt for **"given name(s)"** and **"surname"**. The parts
+        list can be used to represent the terms in the name that have been classified.
+
+    Args:
+        lang (str | None): BCP-47 language tag for this name form (e.g., "en").
+        fullText (str | None): The full, unparsed name string as written in the source.
+            If provided, the name SHOULD be rendered as it would normally be spoken in
+            the applicable cultural context.
+        parts (list[NamePart] | None): Ordered structured components of the name
+            (e.g., Given, Surname). If provided, ``fullText`` may be omitted. If
+            provided, the list SHOULD be ordered such that the parts are in the order
+            they would normally be spoken in the applicable cultural context.
+
+    """
     identifier = 'http://gedcomx.org/v1/NameForm'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
-    def __init__(self, lang: Optional[str] = 'en', fullText: Optional[str] = None,parts: Optional[List[NamePart]] = []) -> None:
+    def __init__(self, lang: Optional[str] = None,
+                 fullText: Optional[str] = None,
+                 parts: Optional[List[NamePart]] = None) -> None:
+        
         self.lang = lang
         self.fullText = fullText
-        self.parts = parts
+        self.parts = parts if parts else []
     
     @property
     def _as_dict_(self):
-        return Serialization.serialize_dict(
-            {'lang': self.lang,
-             'fullText': self.fullText,
-             'parts': [part._as_dict_() for part in self.parts] if self.parts else None})
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.lang:
+            type_as_dict['lang'] = self.lang
+        if self.fullText:
+            type_as_dict['fullText'] = self.fullText
+        if self.parts:
+            type_as_dict['parts'] = [part._as_dict_ for part in self.parts if part]
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict) -> "NameForm":
+        """Build a NameForm from JSON-like dict."""
+        return cls(
+            lang=data.get("lang", "en"),
+            fullText=data.get("fullText"),
+            parts=[NamePart._from_json_(p) for p in ensure_list(data.get("parts"))],
+        )
     
     def _fulltext_parts(self):
         pass
 
 class Name(Conclusion):
+    """**Defines a name of a person.**
+
+            A Name is intended to represent a single variant of a person's name. 
+            This means that nicknames, spelling variations, or other names 
+            (often distinguishable by a name type) should be modeled with 
+            separate instances of Name.
+
+    .. admonition:: Advanced details
+        :class: toggle
+    
+        The name forms of a name contain alternate representations of the name.
+        A Name MUST contain at least one name form, presumably a representation
+        of the name that is considered proper and well formed in the person's native,
+        historical cultural context. Other name forms MAY be included, which can be
+        used to represent this name in contexts where the native name form is not easily
+        recognized and interpreted. Alternate forms are more likely in situations where
+        conclusions are being analyzed across cultural context boundaries that have both
+        language and writing script differences.
+        
+
+    Attributes:
+        type (Optional[:class:`~gedcomx.NameType`]): Classification of the name
+            (e.g., BirthName, AlsoKnownAs).
+        nameForms (List[:class:`~gedcomx.NameForm`]): One or more structured
+            representations of the name (full text and parts).
+        date (Optional[:class:`~gedcomx.Date`]): Date context for this name
+            (e.g., when the name was used or recorded).
+    """
     identifier = 'http://gedcomx.org/v1/Name'
     version = 'http://gedcomx.org/conceptual-model/v1'
 
@@ -163,8 +306,8 @@ class Name(Conclusion):
             name = Name()
         return name
 
-    def __init__(self, id: str = None,
-                 lang: str = 'en',
+    def __init__(self, id: Optional[str] = None,
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Resource = None,
                  notes: Optional[List[Note]] = None,
@@ -187,39 +330,52 @@ class Name(Conclusion):
     
     @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
-            
-        name_as_dict = super()._as_dict_
-
-        name_as_dict.update( {
-            'type':self.type.value if self.type else None,
-            'nameForms': [nameForm._as_dict_ for nameForm in self.nameForms],
-            'date': self.date._as_dict_ if self.date else None})
+        from .Serialization import Serialization
+        type_as_dict = super()._as_dict_
+        if self.type:
+            type_as_dict['type'] = getattr(self.type, 'value', self.type)
+        if self.nameForms:
+            type_as_dict['nameForms'] = [nf._as_dict_ for nf in self.nameForms if nf]
+        if self.date:
+            type_as_dict['date'] = self.date._as_dict_
         
-        #del name_as_dict['id']
-        # Serialize and exclude None values
-        for key, value in name_as_dict.items():
-            if value is not None:
-                name_as_dict[key] = _serialize(value)
-
-        # 3) merge and filter out None *at the top level*
-        return {
-            k: v
-            for k, v in name_as_dict.items()
-            if v is not None
-        }
+        return Serialization.serialize_dict(type_as_dict)
+    
+    @classmethod
+    def _from_json_(cls, data: dict) -> "Name":
+        """Build a Name from JSON-like dict."""
+        return cls(
+            id=data.get("id"),
+            lang=data.get("lang", "en"),
+            sources=[SourceReference._from_json_(s) for s in ensure_list(data.get("sources"))],
+            analysis=Resource._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=NameType(data["type"]) if data.get("type") else None,
+            nameForms=[NameForm._from_json_(nf) for nf in ensure_list(data.get("nameForms"))],
+            date=Date._from_json_(data["date"]) if data.get("date") else None,
+        )
     
-        return name_as_dict
+    def __str__(self) -> str:
+        """Return a human-readable string for the Name-like object."""
+        return f"Name(id={self.id}, type={self.type}, forms={len(self.nameForms)}, date={self.date})"
+
+    def __repr__(self) -> str:
+        """Return an unambiguous string representation of the Name-like object."""
+        return (
+            f"{self.__class__.__name__}("
+            f"id={self.id!r}, "
+            f"lang={self.lang!r}, "
+            f"sources={self.sources!r}, "
+            f"analysis={self.analysis!r}, "
+            f"notes={self.notes!r}, "
+            f"confidence={self.confidence!r}, "
+            f"attribution={self.attribution!r}, "
+            f"type={self.type!r}, "
+            f"nameForms={self.nameForms!r}, "
+            f"date={self.date!r})"
+    )
 
 class QuickName():
     def __new__(cls,name: str) -> Name:
@@ -231,46 +387,10 @@ def ensure_list(val):
         return []
     return val if isinstance(val, list) else [val]
     
-NamePart._from_json_ = classmethod(lambda cls, data: NamePart(
-    type=NamePartType(data['type']) if 'type' in data else None,
-    value=data.get('value'),
-    qualifiers=[NamePartQualifier(q) for q in ensure_list(data.get('qualifiers'))]
-))
-
-NamePart._to_dict_ = lambda self: {
-    'type': self.type.value if self.type else None,
-    'value': self.value,
-    'qualifiers': [q.value for q in self.qualifiers] if self.qualifiers else []
-}
-
-
-# NameForm
-NameForm._from_json_ = classmethod(lambda cls, data: NameForm(
-    lang=data.get('lang', 'en'),
-    fullText=data.get('fullText'),
-    parts=[NamePart._from_json_(p) for p in ensure_list(data.get('parts'))]
-))
-
-NameForm._to_dict_ = lambda self: {
-    'lang': self.lang,
-    'fullText': self.fullText,
-    'parts': [p._to_dict_() for p in self.parts] if self.parts else []
-}
-
-
-# Name
-Name._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=Resource._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=NameType(data['type']) if data.get('type') else None,
-    nameForms=[NameForm._from_json_(nf) for nf in ensure_list(data.get('nameForms'))],
-    date=Date._from_json_(data['date']) if data.get('date') else None
-))
+
+
+
+
 
 
 

gedcomx/Note.py

@@ -1,7 +1,6 @@
 from typing import Optional
 
 from .Attribution import Attribution
-from .Serialization import Serialization
 
 class Note:
     identifier = 'http://gedcomx.org/v1/Note'
@@ -15,20 +14,28 @@ class Note:
 
     def append(self, text_to_add: str):
         if text_to_add and isinstance(text_to_add, str):
-            self.text = self.text + text_to_add
+            if self.text:
+                self.text = self.text + text_to_add
+            else:
+                self.text = text_to_add
         else:
             return #TODO
             raise ValueError("The text to add must be a non-empty string.")
     
     @property
     def _as_dict_(self):
-        note_dict = {
-            "lang":self.lang if self.lang else None,
-            "subject":self.subject if self.subject else None,
-            "text":self.text if self.text else None,
-            "attribution": self.attribution if self.attribution else None
-        }
-        return Serialization.serialize_dict(note_dict)
+        from .Serialization import Serialization
+        type_as_dict = {}
+        if self.lang:
+            type_as_dict["lang"] = self.lang
+        if self.subject:
+            type_as_dict["subject"] = self.subject
+        if self.text:
+            type_as_dict["text"] = self.text
+        if self.attribution:
+            # If attribution exposes `_as_dict_` as a property, use it; otherwise include as-is
+            type_as_dict["attribution"] = getattr(self.attribution, "_as_dict_", self.attribution)
+        return Serialization.serialize_dict(type_as_dict)    
     
     def __eq__(self, other):
         if not isinstance(other, Note):

gedcomx/Person.py

@@ -1,22 +1,38 @@
-from enum import Enum
 from typing import List, Optional
 from urllib.parse import urljoin
 
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    Person.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX Person Type
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
 from .Date import Date
 from .EvidenceReference import EvidenceReference
+from .Extensions.rs10.rsLink import _rsLinkList
 from .Fact import Fact, FactType
 from .Gender import Gender, GenderType
 from .Identifier import IdentifierList
 from .Name import Name, QuickName
 from .Note import Note
+from .Resource import Resource
 from .SourceReference import SourceReference
-from .Serialization import Serialization
 from .Subject import Subject
-from .Resource import Resource
-from collections.abc import Sized
-from .Extensions.rs10.rsLink import _rsLinkList
 
 class Person(Subject):
     """A person in the system.
@@ -40,7 +56,7 @@ class Person(Subject):
              notes: Optional[List[Note]] = None,
              confidence: Optional[ConfidenceLevel] = None,
              attribution: Optional[Attribution] = None,
-             extracted: bool = None,
+             extracted: Optional[bool] = None,
              evidence: Optional[List[EvidenceReference]] = None,
              media: Optional[List[SourceReference]] = None,
              identifiers: Optional[IdentifierList] = None,
@@ -102,7 +118,7 @@ class Person(Subject):
         "ascendancyNumber": "1",
         "deathDate": "from 2001 to 2005",
         "descendancyNumber": "1",
-        "gender": self.gender.type,
+        "gender": self.gender.type if self.gender else 'Unknown',
         "lifespan": "-2005",
         "name": self.names[0].nameForms[0].fullText
             }
@@ -111,17 +127,20 @@ class Person(Subject):
 
     @property
     def _as_dict_(self):
-        type_as_dict = super()._as_dict_  # Start with base class fields
-        # Only add Relationship-specific fields
-        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._as_dict_ for fact in self.facts],
-            'uri': self.uri._as_dict_ if self.uri else None
-                           
-        })
+        from .Serialization import Serialization
+        type_as_dict = super()._as_dict_  
+        if self.private is not None:
+            type_as_dict['private'] = self.private
+        if self.living is not None:
+            type_as_dict['living'] = self.living
+        if self.gender:
+            type_as_dict['gender'] = self.gender._as_dict_
+        if self.names:
+            type_as_dict['names'] = [n._as_dict_ for n in self.names if n]
+        if self.facts:
+            type_as_dict['facts'] = [f._as_dict_ for f in self.facts if f]
+        if self.uri:
+            type_as_dict['uri'] = self.uri._as_dict_
 
         return Serialization.serialize_dict(type_as_dict)
            
@@ -130,10 +149,12 @@ class Person(Subject):
         """
         Create a Person instance from a JSON-dict (already parsed).
         """
+        from .Serialization import Serialization
         return Serialization.deserialize(data, Person)
 
     @classmethod
     def from_familysearch(cls, pid: str, token: str, *, base_url: Optional[str] = None):
+        from .Serialization import Serialization
         """
         Fetch a single person by PID from FamilySearch and return a Person.
         - pid: e.g. "KPHP-4B4"

gedcomx/PlaceDescription.py

@@ -1,24 +1,65 @@
 from typing import List, Optional
 
+"""
+======================================================================
+ Project: Gedcom-X
+ File:    PlaceDescription.py
+ Author:  David J. Cartwright
+ Purpose: Python Object representation of GedcomX PlaceDescription Type
+
+ Created: 2025-08-25
+ Updated:
+   - 2025-08-31: _as_dict_ to only create entries in dict for fields that hold data
+   
+======================================================================
+"""
+
+"""
+======================================================================
+GEDCOM Module Types
+======================================================================
+"""
 from .Attribution import Attribution
 from .Conclusion import ConfidenceLevel
 from .Date import Date
 from .EvidenceReference import EvidenceReference
 from .Identifier import IdentifierList
 from .Note import Note
-from .SourceReference import SourceReference
-from .TextValue import TextValue
 from .Resource import Resource
-from .Serialization import Serialization
+from .SourceReference import SourceReference
 from .Subject import Subject
+from .TextValue import TextValue
 from .URI import URI
 
 class PlaceDescription(Subject):
+    """PlaceDescription describes the details of a place in terms of 
+    its name and possibly its type, time period, and/or a geospatial description
+    functioning as a description of a place as a snapshot in time.
+
+    Encapsulates textual names, geospatial coordinates, jurisdictional context,
+    temporal coverage, and related resources (media, sources, evidence, etc.).
+    
+
+    Attributes:
+        names (Optional[List[TextValue]]): Human-readable names or labels for
+            the place (e.g., “Boston, Suffolk, Massachusetts, United States”).
+        type (Optional[str]): A place type identifier (e.g., a URI). **TODO:**
+            replace with an enumeration when finalized.
+        place (Optional[URI]): Canonical identifier (URI) for the place.
+        jurisdiction (Optional[Resource|PlaceDescription]): The governing or
+            containing jurisdiction of this place (e.g., county for a town).
+        latitude (Optional[float]): Latitude in decimal degrees (WGS84).
+        longitude (Optional[float]): Longitude in decimal degrees (WGS84).
+        temporalDescription (Optional[Date]): Temporal coverage/validity window
+            for this description (e.g., when a jurisdictional boundary applied).
+        spatialDescription (Optional[Resource]): A resource describing spatial
+            geometry or a link to an external gazetteer/shape definition.
+    """
     identifier = "http://gedcomx.org/v1/PlaceDescription"
     version = 'http://gedcomx.org/conceptual-model/v1'
 
     def __init__(self, id: Optional[str] =None,
-                 lang: str = 'en',
+                 lang: Optional[str] = None,
                  sources: Optional[List[SourceReference]] = None,
                  analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] =None,
@@ -29,9 +70,9 @@ class PlaceDescription(Subject):
                  media: Optional[List[SourceReference]] = None,
                  identifiers: Optional[IdentifierList] = None,
                  names: Optional[List[TextValue]] = None,
-                 type: Optional[str] = None,
+                 type: Optional[str] = None,    #TODO This needs to be an enumerated value, work out details
                  place: Optional[URI] = None,
-                 jurisdiction: Optional["Resource | PlaceDescription"] = None, # PlaceDescription
+                 jurisdiction: Optional["Resource | PlaceDescription"] = None, 
                  latitude: Optional[float] = None,
                  longitude: Optional[float] = None,
                  temporalDescription: Optional[Date] = None,
@@ -42,24 +83,33 @@ class PlaceDescription(Subject):
         self.type = type
         self.place = place
         self.jurisdiction = jurisdiction
-        self.latitide = latitude
-        self.longitute = longitude
+        self.latitude = latitude
+        self.longitude = longitude
         self.temporalDescription = temporalDescription
-        self.spacialDescription = spatialDescription
+        self.spatialDescription = spatialDescription
 
     @property
     def _as_dict_(self):
+        from .Serialization import Serialization
         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,
-            "jurisdiction": self.jurisdiction._as_dict_ if self.jurisdiction else None,
-            "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.spacialDescription else None            
-        })
+        
+        if self.names:
+            type_as_dict["names"] = [n._as_dict_ for n in self.names if n]
+        if self.type:
+            type_as_dict["type"] = self.type    #TODO
+        if self.place:
+            type_as_dict["place"] = self.place._as_dict_
+        if self.jurisdiction:
+            type_as_dict["jurisdiction"] = self.jurisdiction._as_dict_ 
+        if self.latitude is not None: # include 0.0; exclude only None
+            type_as_dict["latitude"] = float(self.latitude)
+        if self.longitude is not None: # include 0.0; exclude only None
+            type_as_dict["longitude"] = float(self.longitude)
+        if self.temporalDescription:
+            type_as_dict["temporalDescription"] = self.temporalDescription._as_dict_
+        if self.spatialDescription:
+            type_as_dict["spatialDescription"] = self.spatialDescription._as_dict_
+
         return Serialization.serialize_dict(type_as_dict) 
 
     @classmethod
@@ -67,4 +117,5 @@ class PlaceDescription(Subject):
         """
         Create a PlaceDescription instance from a JSON-dict (already parsed).
         """
+        from .Serialization import Serialization
         return Serialization.deserialize(data, PlaceDescription)