Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #335 from Nick-Hall/bug9897

Browse Source 
9897: Create serialize module
This commit is contained in:
Nick Hall 2017-01-22 16:06:04 +00:00 committed by GitHub
commit db81851195
58 changed files with 144 additions and 2106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
data/tests/imp_MediaTest.gramps
View File

@ -89,6 +89,7 @@
</object>
<object handle="_0000000900000009" change="1472500307" id="M5">
<file src="test.jpg" mime="image/jpeg" description="Multimedia link to linked form FTM style file"/>
<datestr val="6/4/2016 9:33:57 AM"/>
<noteref hlink="_0000001d0000001d"/>
<noteref hlink="_0000001e0000001e"/>
<noteref hlink="_0000001f0000001f"/>

2
gramps/gen/datehandler/test/datehandler_test.py
View File

@ -63,7 +63,7 @@ class DateHandlerTest(unittest.TestCase):
self.assertTrue(test_date.is_equal(new_date),
"{} -> {}\n{} -> {}".format(
test_date, new_date,
test_date.to_struct(), new_date.to_struct()))
test_date.__dict__, new_date.__dict__))
def test_simple(self):

43
gramps/gen/lib/address.py
View File

@ -67,49 +67,6 @@ class Address(SecondaryObject, PrivacyBase, CitationBase, NoteBase, DateBase,
DateBase.serialize(self),
LocationBase.serialize(self))
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Address",
"private": PrivacyBase.serialize(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"date": DateBase.to_struct(self),
"location": LocationBase.to_struct(self)
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Address()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
CitationBase.from_struct(struct.get("citation_list", default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
DateBase.from_struct(struct.get("date", {})),
LocationBase.from_struct(struct.get("location", {}))
)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

31
gramps/gen/lib/addressbase.py
View File

@ -59,37 +59,6 @@ class AddressBase:
"""
return [addr.serialize() for addr in self.address_list]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [addr.to_struct() for addr in self.address_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Address.from_struct(addr) for addr in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

31
gramps/gen/lib/attrbase.py
View File

@ -65,37 +65,6 @@ class AttributeRootBase:
"""
return [attr.serialize() for attr in self.attribute_list]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [attr.to_struct() for attr in self.attribute_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [cls._CLASS.from_struct(attr) for attr in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

77
gramps/gen/lib/attribute.py
View File

@ -77,43 +77,6 @@ class AttributeRoot(SecondaryObject, PrivacyBase):
return (PrivacyBase.serialize(self),
self.type.serialize(), self.value)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": self.__class__.__name__,
"private": PrivacyBase.serialize(self),
"type": self.type.to_struct(),
"value": self.value}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Attribute()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
AttributeType.from_struct(struct.get("type", {})),
struct.get("value", default.value))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.
@ -246,46 +209,6 @@ class Attribute(AttributeRoot, CitationBase, NoteBase):
NoteBase.serialize(self),
self.type.serialize(), self.value)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Attribute",
"private": PrivacyBase.serialize(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"type": self.type.to_struct(),
"value": self.value}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return (PrivacyBase.from_struct(struct["private"]),
CitationBase.from_struct(struct["citation_list"]),
NoteBase.from_struct(struct["note_list"]),
AttributeType.from_struct(struct["type"]),
struct["value"])
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

37
gramps/gen/lib/baseobj.py
View File

@ -56,43 +56,6 @@ class BaseObject(metaclass=ABCMeta):
Convert a serialized tuple of data to an object.
"""
@abstractmethod
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
"""
@abstractmethod
def from_struct(self, struct):
"""
Given a struct data representation, return an object of this type.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns an object of this type.
"""
def matches_string(self, pattern, case_sensitive=False):
"""
Return True if any text data in the object or any of it's child

43
gramps/gen/lib/childref.py
View File

@ -75,49 +75,6 @@ class ChildRef(SecondaryObject, PrivacyBase, CitationBase, NoteBase, RefBase):
self.frel.serialize(),
self.mrel.serialize())
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "ChildRef",
"private": PrivacyBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"ref": Handle("Person", self.ref),
"frel": self.frel.to_struct(),
"mrel": self.mrel.to_struct()}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = ChildRef()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
CitationBase.from_struct(struct.get("citation_list", default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
RefBase.from_struct(struct.get("ref", default.ref)),
ChildRefType.from_struct(struct.get("frel", {})),
ChildRefType.from_struct(struct.get("mrel", {})))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

55
gramps/gen/lib/citation.py
View File

@ -136,61 +136,6 @@ class Citation(MediaBase, NoteBase, SrcAttributeBase, IndirectCitationBase,
TagBase.serialize(self), # 10
self.private) # 11
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Citation",
"handle": Handle("Citation", self.handle), # 0
"gramps_id": self.gramps_id, # 1
"date": DateBase.to_struct(self), # 2
"page": str(self.page), # 3
"confidence": self.confidence, # 4
"source_handle": Handle("Source", self.source_handle), # 5
"note_list": NoteBase.to_struct(self), # 6
"media_list": MediaBase.to_struct(self), # 7
"srcattr_list": SrcAttributeBase.to_struct(self),# 8
"change": self.change, # 9
"tag_list": TagBase.to_struct(self), # 10
"private": self.private} # 11
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Citation()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
DateBase.from_struct(struct.get("date", {})),
struct.get("page", default.page),
struct.get("confidence", default.confidence),
Handle.from_struct(struct.get("source_handle", default.source_handle)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
MediaBase.from_struct(struct.get("media_list", default.media_list)),
SrcAttributeBase.from_struct(struct.get("srcattr_list", [])),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

31
gramps/gen/lib/citationbase.py
View File

@ -75,37 +75,6 @@ class CitationBase:
"""
return self.citation_list
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [Handle("Citation", c) for c in self.citation_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Handle.from_struct(handle) for handle in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

51
gramps/gen/lib/date.py
View File

@ -671,55 +671,6 @@ class Date:
return (self.calendar, self.modifier, self.quality,
self.dateval, text, self.sortval, self.newyear)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Date",
"calendar": self.calendar,
"modifier": self.modifier,
"quality": self.quality,
"dateval": self.dateval,
"text": self.text,
"sortval": self.sortval,
"newyear": self.newyear}
@classmethod
def from_struct(cls, struct, full=False):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Date()
retval = (struct.get("calendar", default.calendar),
struct.get("modifier", default.modifier),
struct.get("quality", default.quality),
struct.get("dateval", default.dateval),
struct.get("text", default.text),
struct.get("sortval", default.sortval),
struct.get("newyear", default.newyear))
if not full and retval == (0, 0, 0, (0, 0, 0, False), '', 0, 0):
return None
else:
return retval
def unserialize(self, data):
"""
Load from the format created by serialize.
@ -1701,7 +1652,7 @@ class Date:
self.__compare(sanity.dateval, value, year_delta)
except DateError as err:
LOG.debug("Sanity check failed - self: {}, sanity: {}".
format(self.to_struct(), sanity.to_struct()))
format(self.__dict__, sanity.__dict__))
err.date = self
raise

35
gramps/gen/lib/datebase.py
View File

@ -61,41 +61,6 @@ class DateBase:
date = self.date.serialize(no_text_date)
return date
def to_struct(self, no_text_date=False):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
if self.date is None:
date = Date().to_struct()
else:
date = self.date.to_struct()
return date
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return Date.from_struct(struct)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

57
gramps/gen/lib/event.py
View File

@ -118,41 +118,6 @@ class Event(CitationBase, NoteBase, MediaBase, AttributeBase,
AttributeBase.serialize(self),
self.change, TagBase.serialize(self), self.private)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Event",
"handle": Handle("Event", self.handle),
"gramps_id": self.gramps_id,
"type": self.__type.to_struct(),
"date": DateBase.to_struct(self),
"description": self.__description,
"place": Handle("Place", self.place),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"media_list": MediaBase.to_struct(self),
"attribute_list": AttributeBase.to_struct(self),
"change": self.change,
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def get_schema(cls):
"""
@ -199,28 +164,6 @@ class Event(CitationBase, NoteBase, MediaBase, AttributeBase,
"private": _("Private"),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Event()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
EventType.from_struct(struct.get("type", {})),
DateBase.from_struct(struct.get("date", {})),
struct.get("description", default.description),
Handle.from_struct(struct.get("place", default.place)),
CitationBase.from_struct(struct.get("citation_list", default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
MediaBase.from_struct(struct.get("media_list", default.media_list)),
AttributeBase.from_struct(struct.get("attribute_list", default.attribute_list)),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

45
gramps/gen/lib/eventref.py
View File

@ -79,35 +79,6 @@ class EventRef(PrivacyBase, NoteBase, AttributeBase, RefBase,
self.__role.serialize()
)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "EventRef",
"private": PrivacyBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"attribute_list": AttributeBase.to_struct(self),
"ref": Handle("Event", self.ref),
"role": self.__role.to_struct()
}
@classmethod
def get_schema(cls):
"""
@ -142,22 +113,6 @@ class EventRef(PrivacyBase, NoteBase, AttributeBase, RefBase,
"role": _("Role"),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = EventRef()
return (
PrivacyBase.from_struct(struct.get("private", default.private)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
AttributeBase.from_struct(struct.get("attribute_list", default.attribute_list)),
RefBase.from_struct(struct.get("ref", default.ref)),
EventRoleType.from_struct(struct.get("role", {}))
)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

72
gramps/gen/lib/family.py
View File

@ -127,78 +127,6 @@ class Family(CitationBase, NoteBase, MediaBase, AttributeBase, LdsOrdBase,
NoteBase.serialize(self),
self.change, TagBase.serialize(self), self.private)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Family",
"handle": Handle("Family", self.handle),
"gramps_id": self.gramps_id,
"father_handle": Handle("Person", self.father_handle),
"mother_handle": Handle("Person", self.mother_handle),
"child_ref_list": [cr.to_struct() for cr in self.child_ref_list],
"type": self.type.to_struct(),
"event_ref_list": [er.to_struct() for er in self.event_ref_list],
"media_list": MediaBase.to_struct(self),
"attribute_list": AttributeBase.to_struct(self),
"lds_ord_list": LdsOrdBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"change": self.change,
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Family()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
Handle.from_struct(struct.get("father_handle",
default.father_handle)),
Handle.from_struct(struct.get("mother_handle",
default.mother_handle)),
[ChildRef.from_struct(cr)
for cr in struct.get("child_ref_list",
default.child_ref_list)],
FamilyRelType.from_struct(struct.get("type", {})),
[EventRef.from_struct(er)
for er in struct.get("event_ref_list",
default.event_ref_list)],
MediaBase.from_struct(struct.get("media_list",
default.media_list)),
AttributeBase.from_struct(struct.get("attribute_list",
default.attribute_list)),
LdsOrdBase.from_struct(struct.get("lds_ord_list",
default.lds_ord_list)),
CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list",
default.note_list)),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
@classmethod
def get_schema(cls):
from .mediaref import MediaRef

38
gramps/gen/lib/grampstype.py
View File

@ -215,44 +215,6 @@ class GrampsType(object, metaclass=GrampsTypeMeta):
"string": _("Family Relationship"),
}
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": self.__class__.__name__,
"value": self.__value,
"string": str(self)}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = cls()
if struct.get("value", cls._CUSTOM) == cls._CUSTOM:
return (struct.get("value", default.value),
struct.get("string", ""))
else:
return (struct.get("value", default.value), '')
def unserialize(self, data):
"""Convert a serialized tuple of data to an object."""
self.__value, self.__string = data

4
gramps/gen/lib/handle.py
View File

@ -53,7 +53,3 @@ def Handle(_classname, handle):
classname = _classname
h = MyHandleClass(handle)
return h
def __from_struct(struct):
return struct
Handle.from_struct = __from_struct

51
gramps/gen/lib/ldsord.py
View File

@ -144,57 +144,6 @@ class LdsOrd(SecondaryObject, CitationBase, NoteBase,
self.type, self.place,
self.famc, self.temple, self.status, self.private)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "LdsOrd",
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"date": DateBase.to_struct(self),
"type": self.type,
"place": self.place,
"famc": self.famc,
"temple": self.temple,
"status": self.status,
"private": self.private}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = LdsOrd()
return (CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list",
default.note_list)),
DateBase.from_struct(struct.get("date", {})),
struct.get("type", {}),
struct.get("place", default.place),
struct.get("famc", default.famc),
struct.get("temple", default.temple),
struct.get("status", default.status),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

31
gramps/gen/lib/ldsordbase.py
View File

@ -64,37 +64,6 @@ class LdsOrdBase:
"""
return [lds_ord.serialize() for lds_ord in self.lds_ord_list]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [lds_ord.to_struct() for lds_ord in self.lds_ord_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [LdsOrd.from_struct(lds_ord) for lds_ord in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object

49
gramps/gen/lib/location.py
View File

@ -63,55 +63,6 @@ class Location(SecondaryObject, LocationBase):
"""
return (LocationBase.serialize(self), self.parish)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Location",
"street": self.street,
"locality": self.locality,
"city": self.city,
"county": self.county,
"state": self.state,
"country": self.country,
"postal": self.postal,
"phone": self.phone,
"parish": self.parish}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Location()
return ((struct.get("street", default.street),
struct.get("locality", default.locality),
struct.get("city", default.city),
struct.get("country", default.country),
struct.get("state", default.state),
struct.get("country", default.country),
struct.get("postal", default.postal),
struct.get("phone", default.phone)),
struct.get("parish", default.parish))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

49
gramps/gen/lib/locationbase.py
View File

@ -64,55 +64,6 @@ class LocationBase:
return (self.street, self.locality, self.city, self.county, self.state,
self.country, self.postal, self.phone)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "LocationBase",
"street": self.street,
"locality": self.locality,
"city": self.city,
"county": self.county,
"state": self.state,
"country": self.country,
"postal": self.postal,
"phone": self.phone
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = LocationBase()
return (struct.get("street", default.street),
struct.get("locality", default.locality),
struct.get("city", default.city),
struct.get("county", default.county),
struct.get("state", default.state),
struct.get("country", default.country),
struct.get("postal", default.postal),
struct.get("phone", default.phone))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

57
gramps/gen/lib/media.py
View File

@ -118,41 +118,6 @@ class Media(CitationBase, NoteBase, DateBase, AttributeBase,
TagBase.serialize(self),
self.private)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Media",
"handle": Handle("Media", self.handle),
"gramps_id": self.gramps_id,
"path": self.path,
"mime": self.mime,
"desc": self.desc,
"checksum": self.checksum,
"attribute_list": AttributeBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"change": self.change,
"date": DateBase.to_struct(self),
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def get_schema(cls):
"""
@ -205,28 +170,6 @@ class Media(CitationBase, NoteBase, DateBase, AttributeBase,
"private": _("Private"),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Media()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
struct.get("path", default.path),
struct.get("mime", default.mime),
struct.get("desc", default.desc),
struct.get("checksum", default.checksum),
AttributeBase.from_struct(struct.get("attribute_list", default.attribute_list)),
CitationBase.from_struct(struct.get("citation_list", default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
struct.get("change", default.change),
DateBase.from_struct(struct.get("date", {})),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

31
gramps/gen/lib/mediabase.py
View File

@ -56,37 +56,6 @@ class MediaBase:
"""
return [mref.serialize() for mref in self.media_list]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [mref.to_struct() for mref in self.media_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [MediaRef.from_struct(mref) for mref in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

46
gramps/gen/lib/mediaref.py
View File

@ -70,34 +70,6 @@ class MediaRef(SecondaryObject, PrivacyBase, CitationBase, NoteBase, RefBase,
RefBase.serialize(self),
self.rect)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "MediaRef",
"private": PrivacyBase.serialize(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"attribute_list": AttributeBase.to_struct(self),
"ref": Handle("Media", self.ref),
"rect": self.rect if self.rect != (0, 0, 0, 0) else None}
@classmethod
def get_schema(cls):
"""
@ -118,24 +90,6 @@ class MediaRef(SecondaryObject, PrivacyBase, CitationBase, NoteBase, RefBase,
"rect": tuple, # or None if (0,0,0,0)
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = MediaRef()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list",
default.note_list)),
AttributeBase.from_struct(struct.get("attribute_list",
default.attribute_list)),
RefBase.from_struct(struct.get("ref", default.ref)),
struct.get("rect", default.rect))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

64
gramps/gen/lib/name.py
View File

@ -129,70 +129,6 @@ class Name(SecondaryObject, PrivacyBase, SurnameBase, CitationBase, NoteBase,
self.group_as, self.sort_as, self.display_as, self.call,
self.nick, self.famnick)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Name",
"private": PrivacyBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"date": DateBase.to_struct(self),
"first_name": self.first_name,
"surname_list": SurnameBase.to_struct(self),
"suffix": self.suffix,
"title": self.title,
"type": self.type.to_struct(),
"group_as": self.group_as,
"sort_as": self.sort_as,
"display_as": self.display_as,
"call": self.call,
"nick": self.nick,
"famnick": self.famnick}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Name()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list",
default.note_list)),
DateBase.from_struct(struct.get("date", {})),
struct.get("first_name", default.first_name),
SurnameBase.from_struct(struct.get("surname_list",
default.surname_list)),
struct.get("suffix", default.suffix),
struct.get("title", default.title),
NameType.from_struct(struct.get("type", {})),
struct.get("group_as", default.group_as),
struct.get("sort_as", default.sort_as),
struct.get("display_as", default.display_as),
struct.get("call", default.call),
struct.get("nick", default.nick),
struct.get("famnick", default.famnick))
@classmethod
def get_labels(cls, _):
return {

47
gramps/gen/lib/note.py
View File

@ -95,36 +95,6 @@ class Note(BasicPrimaryObject):
self.type.serialize(), self.change, TagBase.serialize(self),
self.private)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Note",
"handle": Handle("Note", self.handle),
"gramps_id": self.gramps_id,
"text": self.text.to_struct(),
"format": self.format,
"type": self.type.to_struct(),
"change": self.change,
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def get_schema(cls):
"""
@ -154,23 +124,6 @@ class Note(BasicPrimaryObject):
"private": _("Private"),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Note()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
StyledText.from_struct(struct.get("text", {})),
struct.get("format", default.format),
NoteType.from_struct(struct.get("type", {})),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""Convert a serialized tuple of data to an object.

31
gramps/gen/lib/notebase.py
View File

@ -53,37 +53,6 @@ class NoteBase:
"""
return self.note_list
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [Handle("Note", n) for n in self.note_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Handle.from_struct(n) for n in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

93
gramps/gen/lib/person.py
View File

@ -157,56 +157,6 @@ class Person(CitationBase, NoteBase, AttributeBase, MediaBase,
[pr.serialize() for pr in self.person_ref_list] # 20
)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "Person",
"handle": Handle("Person", self.handle), # 0
"gramps_id": self.gramps_id, # 1
"gender": self.__gender, # 2
"primary_name": self.primary_name.to_struct(), # 3
"alternate_names": [name.to_struct()
for name in self.alternate_names], # 4
"death_ref_index": self.death_ref_index, # 5
"birth_ref_index": self.birth_ref_index, # 6
"event_ref_list": [er.to_struct()
for er in self.event_ref_list], # 7
"family_list": [Handle("Family", f) for f in
self.family_list], # 8
"parent_family_list": [Handle("Family", f) for f in
self.parent_family_list], # 9
"media_list": MediaBase.to_struct(self), # 10
"address_list": AddressBase.to_struct(self), # 11
"attribute_list": AttributeBase.to_struct(self), # 12
"urls": UrlBase.to_struct(self), # 13
"lds_ord_list": LdsOrdBase.to_struct(self), # 14
"citation_list": CitationBase.to_struct(self), # 15
"note_list": NoteBase.to_struct(self), # 16
"change": self.change, # 17
"tag_list": TagBase.to_struct(self), # 18
"private": self.private, # 19
"person_ref_list": [pr.to_struct()
for pr in self.person_ref_list] # 20
}
@classmethod
def get_labels(cls, _):
return {
@ -234,49 +184,6 @@ class Person(CitationBase, NoteBase, AttributeBase, MediaBase,
"probably_alive": _("Probably alive"),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Person()
return (
Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
struct.get("gender", default.gender),
Name.from_struct(struct.get("primary_name", {})),
[Name.from_struct(name)
for name in struct.get("alternate_names",
default.alternate_names)],
struct.get("death_ref_index", default.death_ref_index),
struct.get("birth_ref_index", default.birth_ref_index),
[EventRef.from_struct(er)
for er in struct.get("event_ref_list", default.event_ref_list)],
[Handle.from_struct(handle)
for handle in struct.get("family_list", default.family_list)],
[Handle.from_struct(handle)
for handle in struct.get("parent_family_list",
default.parent_family_list)],
MediaBase.from_struct(struct.get("media_list", default.media_list)),
AddressBase.from_struct(struct.get("address_list",
default.address_list)),
AttributeBase.from_struct(struct.get("attribute_list",
default.attribute_list)),
UrlBase.from_struct(struct.get("urls", default.urls)),
LdsOrdBase.from_struct(struct.get("lds_ord_list",
default.lds_ord_list)),
CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private),
[PersonRef.from_struct(p)
for p in struct.get("person_ref_list", default.person_ref_list)]
)
@classmethod
def get_schema(cls):
"""

41
gramps/gen/lib/personref.py
View File

@ -72,47 +72,6 @@ class PersonRef(SecondaryObject, PrivacyBase, CitationBase, NoteBase, RefBase):
RefBase.serialize(self),
self.rel)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "PersonRef",
"private": PrivacyBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"ref": Handle("Person", self.ref),
"rel": self.rel}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = PersonRef()
return (PrivacyBase.from_struct(struct.get("private", default.private)),
CitationBase.from_struct(struct.get("citation_list", default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
RefBase.from_struct(struct.get("ref", default.ref)),
struct.get("rel", default.rel))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

72
gramps/gen/lib/place.py
View File

@ -166,78 +166,6 @@ class Place(CitationBase, NoteBase, MediaBase, UrlBase, PrimaryObject):
"private": bool
}
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Place",
"handle": Handle("Place", self.handle),
"gramps_id": self.gramps_id,
"title": self.title,
"long": self.long,
"lat": self.lat,
"placeref_list": [pr.to_struct() for pr in self.placeref_list],
"name": self.name.to_struct(),
"alt_names": [an.to_struct() for an in self.alt_names],
"place_type": self.place_type.to_struct(),
"code": self.code,
"alt_loc": [al.to_struct() for al in self.alt_loc],
"urls": UrlBase.to_struct(self),
"media_list": MediaBase.to_struct(self),
"citation_list": CitationBase.to_struct(self),
"note_list": NoteBase.to_struct(self),
"change": self.change,
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Place()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
struct.get("title", default.title),
struct.get("long", default.long),
struct.get("lat", default.lat),
[PlaceRef.from_struct(pr)
for pr in struct.get("placeref_list", default.placeref_list)],
PlaceName.from_struct(struct.get("name", {})),
[PlaceName.from_struct(an)
for an in struct.get("alt_names", default.alt_names)],
PlaceType.from_struct(struct.get("place_type", {})),
struct.get("code", default.code),
[Location.from_struct(al)
for al in struct.get("alt_loc", default.alt_loc)],
UrlBase.from_struct(struct.get("urls", default.urls)),
MediaBase.from_struct(struct.get("media_list",
default.media_list)),
CitationBase.from_struct(struct.get("citation_list",
default.citation_list)),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

41
gramps/gen/lib/placename.py
View File

@ -71,47 +71,6 @@ class PlaceName(SecondaryObject, DateBase):
self.lang
)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "PlaceName",
"value": self.value,
"date": DateBase.to_struct(self),
"lang": self.lang
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = PlaceName()
return (
struct.get("value", default.value),
DateBase.from_struct(struct.get("date", {})),
struct.get("lang", default.lang)
)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

39
gramps/gen/lib/placeref.py
View File

@ -63,45 +63,6 @@ class PlaceRef(RefBase, DateBase, SecondaryObject):
DateBase.serialize(self)
)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "PlaceRef",
"ref": Handle("Place", self.ref),
"date": DateBase.to_struct(self)
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = PlaceRef()
return (
RefBase.from_struct(struct.get("ref", default.ref)),
DateBase.from_struct(struct.get("date", {}))
)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

74
gramps/gen/lib/primaryobj.py
View File

@ -90,43 +90,6 @@ class BasicPrimaryObject(TableObject, PrivacyBase, TagBase):
Convert a serialized tuple of data to an object.
"""
@abstractmethod
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
"""
@abstractmethod
def from_struct(self, struct):
"""
Given a struct data representation, return an object of this type.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns an object of this type.
"""
def set_gramps_id(self, gramps_id):
"""
Set the Gramps ID for the primary object.
@ -278,43 +241,6 @@ class PrimaryObject(BasicPrimaryObject):
Convert a serialized tuple of data to an object.
"""
@abstractmethod
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
"""
@abstractmethod
def from_struct(self, struct):
"""
Given a struct data representation, return an object of this type.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns an object of this type.
"""
def has_handle_reference(self, classname, handle):
"""
Return True if the object has reference to a given handle of given

31
gramps/gen/lib/privacybase.py
View File

@ -55,37 +55,6 @@ class PrivacyBase:
"""
return self.private
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: bool
"""
return self.private
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return struct
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

9
gramps/gen/lib/refbase.py
View File

@ -53,15 +53,6 @@ class RefBase(metaclass=ABCMeta):
"""
return self.ref
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return str(struct)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

51
gramps/gen/lib/repo.py
View File

@ -104,57 +104,6 @@ class Repository(NoteBase, AddressBase, UrlBase, IndirectCitationBase,
"private": bool
}
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Repository",
"handle": Handle("Repository", self.handle),
"gramps_id": self.gramps_id,
"type": self.type.to_struct(),
"name": str(self.name),
"note_list": NoteBase.to_struct(self),
"address_list": AddressBase.to_struct(self),
"urls": UrlBase.to_struct(self),
"change": self.change,
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Repository()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
RepositoryType.from_struct(struct.get("type", {})),
struct.get("name", default.name),
NoteBase.from_struct(struct.get("note_list", default.note_list)),
AddressBase.from_struct(struct.get("address_list", default.address_list)),
UrlBase.from_struct(struct.get("urls", default.urls)),
struct.get("change", default.change),
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

45
gramps/gen/lib/reporef.py
View File

@ -69,51 +69,6 @@ class RepoRef(SecondaryObject, PrivacyBase, NoteBase, RefBase):
PrivacyBase.serialize(self),
)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {
"_class": "RepositoryRef",
"note_list": NoteBase.to_struct(self),
"ref": Handle("Repository", self.ref),
"call_number": self.call_number,
"media_type": self.media_type.to_struct(),
"private": PrivacyBase.serialize(self),
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = RepoRef()
return (
NoteBase.from_struct(struct.get("note_list", default.note_list)),
RefBase.from_struct(struct.get("ref", default.ref)),
struct.get("call_number", default.call_number),
SourceMediaType.from_struct(struct.get("media_type", {})),
struct.get("private", default.private),
)
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

53
gramps/gen/lib/researcher.py
View File

@ -60,59 +60,6 @@ class Researcher(LocationBase):
return (LocationBase.serialize(self),
self.name, self.addr, self.email)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Researcher",
"street": self.street,
"locality": self.locality,
"city": self.city,
"county": self.county,
"state": self.state,
"country": self.country,
"postal": self.postal,
"phone": self.phone,
"name": self.name,
"address": self.addr,
"email": self.email}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Researcher()
return (struct.get("street", default.street),
struct.get("locality", default.locality),
struct.get("city", default.city),
struct.get("country", default.country),
struct.get("state", default.state),
struct.get("country", default.country),
struct.get("postal", default.postal),
struct.get("phone", default.phone),
struct.get("name", default.name),
struct.get("address", default.addr),
struct.get("email", default.email))
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

37
gramps/gen/lib/secondaryobj.py
View File

@ -59,43 +59,6 @@ class SecondaryObject(BaseObject):
Convert a serialized tuple of data to an object.
"""
@abstractmethod
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
"""
@abstractmethod
def from_struct(self, struct):
"""
Given a struct data representation, return an object of this type.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns an object of this type.
"""
def is_equal(self, source):
return self.serialize() == source.serialize()

89
gramps/gen/lib/serialize.py Normal file
View File

@ -0,0 +1,89 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2017 Nick Hall
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
"""
Serialization utilities for Gramps.
"""
#------------------------------------------------------------------------
#
# Python modules
#
#------------------------------------------------------------------------
import json
#------------------------------------------------------------------------
#
# Gramps modules
#
#------------------------------------------------------------------------
import gramps.gen.lib as lib
def __default(obj):
obj_dict = {'_class': obj.__class__.__name__}
if isinstance(obj, lib.GrampsType):
obj_dict['string'] = getattr(obj, 'string')
if isinstance(obj, lib.Date):
if obj.is_empty() and not obj.text:
return None
for key, value in obj.__dict__.items():
if not key.startswith('_'):
obj_dict[key] = value
for key, value in obj.__class__.__dict__.items():
if isinstance(value, property):
if key != 'year':
obj_dict[key] = getattr(obj, key)
return obj_dict
def __object_hook(obj_dict):
obj = getattr(lib, obj_dict['_class'])()
for key, value in obj_dict.items():
if key != '_class':
if key in ('dateval', 'rect') and value is not None:
value = tuple(value)
if key == 'ranges':
value = [tuple(item) for item in value]
setattr(obj, key, value)
if obj_dict['_class'] == 'Date':
if obj.is_empty() and not obj.text:
return None
return obj
def to_json(obj):
"""
Encode a Gramps object in JSON format.
:param obj: The object to be serialized.
:type obj: object
:returns: A JSON string.
:rtype: str
"""
return json.dumps(obj, default=__default)
def from_json(data):
"""
Decode JSON data into a Gramps object hierarchy.
:param data: The JSON string to be unserialized.
:type data: str
:returns: A Gramps object.
:rtype: object
"""
return json.loads(data, object_hook=__object_hook)

61
gramps/gen/lib/src.py
View File

@ -121,67 +121,6 @@ class Source(MediaBase, NoteBase, SrcAttributeBase, IndirectCitationBase,
"private": bool
}
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Source",
"handle": Handle("Source", self.handle),
"gramps_id": self.gramps_id,
"title": str(self.title),
"author": str(self.author),
"pubinfo": str(self.pubinfo),
"note_list": NoteBase.to_struct(self),
"media_list": MediaBase.to_struct(self),
"abbrev": str(self.abbrev),
"change": self.change,
"srcattr_list": SrcAttributeBase.to_struct(self),
"reporef_list": [rr.to_struct() for rr in self.reporef_list],
"tag_list": TagBase.to_struct(self),
"private": self.private}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
from .srcattribute import SrcAttribute
default = Source()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("gramps_id", default.gramps_id),
struct.get("title", default.title),
struct.get("author", default.author),
struct.get("pubinfo", default.pubinfo),
NoteBase.from_struct(struct.get("note_list",
default.note_list)),
MediaBase.from_struct(struct.get("media_list",
default.media_list)),
struct.get("abbrev", default.abbrev),
struct.get("change", default.change),
SrcAttributeBase.from_struct(struct.get("srcattr_list", {})),
[RepoRef.from_struct(rr)
for rr in struct.get("reporef_list", default.reporef_list)],
TagBase.from_struct(struct.get("tag_list", default.tag_list)),
struct.get("private", default.private))
def unserialize(self, data):
"""
Convert the data held in a tuple created by the serialize method

60
gramps/gen/lib/styledtext.py
View File

@ -288,47 +288,6 @@ class StyledText:
return (self._string, the_tags)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:return: Returns a struct containing the data of the object.
:rtype: dict
"""
if self._tags:
the_tags = [tag.to_struct() for tag in self._tags]
else:
the_tags = []
return {"_class": "StyledText",
"string": self._string,
"tags": the_tags}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:return: Returns a serialized object
"""
default = StyledText()
return (struct.get("string", default.string),
[StyledTextTag.from_struct(t)
for t in struct.get("tags", default.tags)])
@classmethod
def get_schema(cls):
"""
@ -372,14 +331,29 @@ class StyledText:
"""
return self._tags
def set_tags(self, tags):
"""
Set the list of formatting tags.
:param tags: The formatting tags applied on the text.
:type tags: list of 0 or more :py:class:`.StyledTextTag` instances.
"""
self._tags = tags
def get_string(self):
"""
Accessor for the associated string.
"""
return self._string
tags = property(get_tags)
string = property(get_string)
def set_string(self, string):
"""
Setter for the associated string.
"""
self._string = string
tags = property(get_tags, set_tags)
string = property(get_string, set_string)
if __name__ == '__main__':
from .styledtexttagtype import StyledTextTagType

37
gramps/gen/lib/styledtexttag.py
View File

@ -72,43 +72,6 @@ class StyledTextTag:
"""
return (self.name.serialize(), self.value, self.ranges)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:return: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "StyledTextTag",
"name": self.name.to_struct(),
"value": self.value,
"ranges": self.ranges}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:return: Returns a serialized object
"""
default = StyledTextTag()
return (StyledTextTagType.from_struct(struct.get("name", {})),
struct.get("value", default.value),
struct.get("ranges", default.ranges))
def unserialize(self, data):
"""Convert a serialized tuple of data to an object.

41
gramps/gen/lib/surname.py
View File

@ -71,33 +71,6 @@ class Surname(SecondaryObject):
return (self.surname, self.prefix, self.primary,
self.origintype.serialize(), self.connector)
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Surname",
"surname": self.surname,
"prefix": self.prefix,
"primary": self.primary,
"origintype": self.origintype.to_struct(),
"connector": self.connector}
@classmethod
def get_schema(cls):
return {
@ -119,20 +92,6 @@ class Surname(SecondaryObject):
"connector": _("Connector")
}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Surname()
return (struct.get("surname", default.surname),
struct.get("prefix", default.prefix),
struct.get("primary", default.primary),
NameOriginType.from_struct(struct.get("origintype", {})),
struct.get("connector", default.connector))
def is_empty(self):
"""
Indicate if the surname is empty.

31
gramps/gen/lib/surnamebase.py
View File

@ -60,37 +60,6 @@ class SurnameBase:
"""
return [surname.serialize() for surname in self.surname_list]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [surname.to_struct() for surname in self.surname_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Surname.from_struct(surname) for surname in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

37
gramps/gen/lib/tableobj.py
View File

@ -92,43 +92,6 @@ class TableObject(BaseObject):
Convert a serialized tuple of data to an object.
"""
@abstractmethod
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
"""
@abstractmethod
def from_struct(self, struct):
"""
Given a struct data representation, return an object of this type.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns an object of this type.
"""
def get_change_time(self):
"""
Return the time that the data was last changed.

41
gramps/gen/lib/tag.py
View File

@ -225,46 +225,5 @@ class Tag(TableObject):
"""
return self.__priority
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Tag",
"handle": Handle("Tag", self.handle),
"name": self.__name,
"color": self.__color,
"priority": self.__priority,
"change": self.change}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Tag()
return (Handle.from_struct(struct.get("handle", default.handle)),
struct.get("name", default.name),
struct.get("color", default.color),
struct.get("priority", default.priority),
struct.get("change", default.change))
priority = property(get_priority, set_priority, None,
'Returns or sets priority of the tag')

31
gramps/gen/lib/tagbase.py
View File

@ -55,37 +55,6 @@ class TagBase:
"""
return self.tag_list
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [Handle('Tag', t) for t in self.tag_list]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Handle.from_struct(t) for t in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

5
gramps/gen/lib/test/date_test.py
View File

@ -245,7 +245,8 @@ class ParserDateTest(BaseDateTest):
"dateval fails is_equal in format %d:\n"
" '%s' != '%s'\n"
" '%s' != '%s'\n" %
(date_format, dateval, ndate, dateval.to_struct(), ndate.to_struct()))
(date_format, dateval, ndate,
dateval.__dict__, ndate.__dict__))
def test_basic(self):
self.do_case("basic test")
@ -380,7 +381,7 @@ class MatchDateTest(BaseDateTest):
d1,
("did not match" if expected else "matched"),
d2,
date1.to_struct(), date2.to_struct()))
date1.__dict__, date2.__dict__))
def test_match(self):
for testdata in self.tests:

28
gramps/gen/lib/test/struct_test.py → gramps/gen/lib/test/serialize_test.py
View File

@ -18,13 +18,14 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
""" Unittest for to_struct, from_struct """
""" Unittest for to_json, from_json """
import unittest
import os
from .. import (Person, Family, Event, Source, Place, Citation,
Repository, Media, Note, Tag)
from .. import (Person, Family, Event, Source, Place, Citation,
Repository, Media, Note, Tag)
from ..serialize import to_json, from_json
from gramps.gen.db.utils import import_as_dict
from gramps.cli.user import User
from gramps.gen.const import DATA_DIR
@ -33,14 +34,15 @@ TEST_DIR = os.path.abspath(os.path.join(DATA_DIR, "tests"))
EXAMPLE = os.path.join(TEST_DIR, "example.gramps")
class BaseCheck:
def test_from_struct(self):
struct = self.object.to_struct()
serialized = self.cls.from_struct(struct)
self.assertEqual(self.object.serialize(), serialized)
def test_from_json(self):
data = to_json(self.object)
obj = from_json(data)
self.assertEqual(self.object.serialize(), obj.serialize())
def test_from_empty_struct(self):
serialized = self.cls.from_struct({})
self.assertEqual(self.object.serialize(), serialized)
def test_from_empty_json(self):
data = '{"_class": "%s"}' % self.cls.__name__
obj = from_json(data)
self.assertEqual(self.object.serialize(), obj.serialize())
class PersonCheck(unittest.TestCase, BaseCheck):
def setUp(self):
@ -99,10 +101,10 @@ def generate_case(obj):
"""
Dynamically generate tests and attach to DatabaseCheck.
"""
struct = obj.to_struct()
serialized = obj.__class__.from_struct(struct)
data = to_json(obj)
obj2 = from_json(data)
def test(self):
self.assertEqual(obj.serialize(), serialized)
self.assertEqual(obj.serialize(), obj2.serialize())
name = "test_serialize_%s_%s" % (obj.__class__.__name__, obj.handle)
setattr(DatabaseCheck, name, test)
####

39
gramps/gen/lib/url.py
View File

@ -67,45 +67,6 @@ class Url(SecondaryObject, PrivacyBase):
def serialize(self):
return (self.private, self.path, self.desc, self.type.serialize())
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: dict
"""
return {"_class": "Url",
"private": self.private,
"path": self.path,
"desc": self.desc,
"type": self.type.to_struct()}
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
default = Url()
return (struct.get("private", default.private),
struct.get("path", default.path),
struct.get("desc", default.desc),
UrlType.from_struct(struct.get("type", {})))
def unserialize(self, data):
(self.private, self.path, self.desc, type_value) = data
self.type.unserialize(type_value)

31
gramps/gen/lib/urlbase.py
View File

@ -58,37 +58,6 @@ class UrlBase:
"""
return [url.serialize() for url in self.urls]
def to_struct(self):
"""
Convert the data held in this object to a structure (eg,
struct) that represents all the data elements.
This method is used to recursively convert the object into a
self-documenting form that can easily be used for various
purposes, including diffs and queries.
These structures may be primitive Python types (string,
integer, boolean, etc.) or complex Python types (lists,
tuples, or dicts). If the return type is a dict, then the keys
of the dict match the fieldname of the object. If the return
struct (or value of a dict key) is a list, then it is a list
of structs. Otherwise, the struct is just the value of the
attribute.
:returns: Returns a struct containing the data of the object.
:rtype: list
"""
return [url.to_struct() for url in self.urls]
@classmethod
def from_struct(cls, struct):
"""
Given a struct data representation, return a serialized object.
:returns: Returns a serialized object
"""
return [Url.from_struct(url) for url in struct]
def unserialize(self, data):
"""
Convert a serialized tuple of data to an object.

11
gramps/gen/merge/diff.py
View File

@ -22,11 +22,20 @@
This package implements an object difference engine.
"""
import json
from gramps.cli.user import User
from ..db.utils import import_as_dict
from ..lib.serialize import to_json
from ..const import GRAMPS_LOCALE as glocale
_ = glocale.translation.gettext
def to_struct(obj):
"""
Convert an object into a struct.
"""
return json.loads(to_json(obj))
def diff_dates(json1, json2):
"""
Compare two json date objects. Returns True if different.
@ -110,7 +119,7 @@ def diff_dbs(db1, db2, user=None):
if handles1[p1] == handles2[p2]: # in both
item1 = db1.get_table_func(item,"handle_func")(handles1[p1])
item2 = db2.get_table_func(item,"handle_func")(handles2[p2])
diff = diff_items(item, item1.to_struct(), item2.to_struct())
diff = diff_items(item, to_struct(item1), to_struct(item2))
if diff:
diffs += [(item, item1, item2)]
# else same!

2
gramps/gui/editors/editdate.py
View File

@ -258,7 +258,7 @@ class EditDate(ManagedWindow):
newyear=the_newyear)
# didn't throw yet?
self.validated_date = d
LOG.debug("validated_date set to: {0}".format(d.to_struct()))
LOG.debug("validated_date set to: {0}".format(d.__dict__))
self.ok_button.set_sensitive(1)
self.calendar_box.set_sensitive(1)
return True

2
gramps/plugins/importer/importgeneweb.py
View File

@ -909,7 +909,7 @@ class GeneWebParser:
LOG.warning(_(
"Invalid date {date} in {gw_snippet}, "
"preserving date as text."
).format(date=e.date.to_struct(), gw_snippet=field))
).format(date=e.date.__dict__, gw_snippet=field))
date.set(modifier=Date.MOD_TEXTONLY, text=field)
return date
else:

2
gramps/plugins/importer/importxml.py
View File

@ -2499,7 +2499,7 @@ class GrampsParser(UpdateCallback):
# TRANSLATORS: leave the {date} and {xml} untranslated in the format string,
# but you may re-order them if needed.
LOG.warning(_("Invalid date {date} in XML {xml}, preserving XML as text"
).format(date=date_error.date.to_struct(), xml=xml))
).format(date=date_error.date.__dict__, xml=xml))
date_value.set(modifier=Date.MOD_TEXTONLY, text=xml)
def start_datestr(self, attrs):

6
gramps/plugins/test/test_imports.py
View File

@ -30,7 +30,7 @@ from unittest.mock import patch
#import logging
from gramps.gen.db.utils import import_as_dict
from gramps.gen.merge.diff import diff_dbs
from gramps.gen.merge.diff import diff_dbs, to_struct
from gramps.gen.simple import SimpleAccess
from gramps.gen.utils.id import set_det_id
from gramps.cli.user import User
@ -75,8 +75,8 @@ class CompleteCheck(unittest.TestCase):
if diffs:
for diff in diffs:
obj_type, item1, item2 = diff
msg = self._report_diff(obj_type, item1.to_struct(),
item2.to_struct())
msg = self._report_diff(obj_type, to_struct(item1),
to_struct(item2))
if msg != "":
if hasattr(item1, "gramps_id"):
self.msg += "%s: %s handle=%s\n" % \

1
po/POTFILES.skip
View File

@ -164,6 +164,7 @@ gramps/gen/lib/repo.py
gramps/gen/lib/reporef.py
gramps/gen/lib/researcher.py
gramps/gen/lib/secondaryobj.py
gramps/gen/lib/serialize.py
gramps/gen/lib/src.py
gramps/gen/lib/srcbase.py
gramps/gen/lib/srcref.py