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

DB-API and DbDictionary both use same binary handles as BSDDB

Browse Source
This commit is contained in:
Doug Blank 2016-01-31 09:15:52 -05:00
parent 2fb9a018c7
commit 403c87b887
4 changed files with 183 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
gramps/gen/db/generic.py
View File

@ -1,7 +1,7 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2015 Douglas S. Blank <doug.blank@gmail.com>
# Copyright (C) 2015-2016 Gramps Development Team
#
# 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
@ -34,6 +34,7 @@ import shutil
import bisect
import ast
import sys
import datetime
#------------------------------------------------------------------------
#
@ -272,10 +273,10 @@ class Map(object):
def __setitem__(self, key, value):
"""
This is only done in a low-level raw import.
This is only done in a assignment via key.
value: serialized object
key: bytes key (ignored in this implementation)
key: bytes key (ignored in this function)
"""
obj = self.table.funcs["class_func"].create(value)
self.table.funcs["commit_func"](obj, self.txn)
@ -318,7 +319,7 @@ class Cursor(object):
return self
def __iter__(self):
for item in self.map.keys():
yield (bytes(item, "utf-8"), self.map[item])
yield (item, self.map[item])
def __next__(self):
try:
return self._iter.__next__()
@ -328,7 +329,7 @@ class Cursor(object):
pass
def iter(self):
for item in self.map.keys():
yield (bytes(item, "utf-8"), self.map[item])
yield (item, self.map[item])
def first(self):
self._iter = self.__iter__()
try:
@ -357,7 +358,7 @@ class TreeCursor(Cursor):
"""
handles = self.db.get_place_handles(sort_handles=True)
for handle in handles:
yield (bytes(handle, "utf-8"), self.db._get_raw_place_data(handle))
yield (handle, self.db._get_raw_place_data(handle))
class Bookmarks(object):
def __init__(self, default=[]):
@ -1265,63 +1266,103 @@ class DbGeneric(DbWriteBase, DbReadBase, UpdateCallback, Callback):
return gramps_id in key2table[obj_key]
def has_person_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.person_map
def has_family_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.family_map
def has_citation_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.citation_map
def has_source_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.source_map
def has_repository_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.repository_map
def has_note_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.note_map
def has_place_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.place_map
def has_event_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.event_map
def has_tag_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.tag_map
def has_media_handle(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return handle in self.media_map
def get_raw_person_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.person_map[handle]
def get_raw_family_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.family_map[handle]
def get_raw_citation_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.citation_map[handle]
def get_raw_source_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.source_map[handle]
def get_raw_repository_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.repository_map[handle]
def get_raw_note_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.note_map[handle]
def get_raw_place_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.place_map[handle]
def get_raw_media_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.media_map[handle]
def get_raw_tag_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.tag_map[handle]
def get_raw_event_data(self, handle):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
return self.event_map[handle]
def add_person(self, person, trans, set_gid=True):
@ -1517,6 +1558,8 @@ class DbGeneric(DbWriteBase, DbReadBase, UpdateCallback, Callback):
class_ = db._tables[key]["class_func"]
for (handle, data) in cursor():
map = getattr(self, "%s_map" % key.lower())
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
map[handle] = class_.create(data)
def get_transaction_class(self):
@ -1990,7 +2033,8 @@ class DbGeneric(DbWriteBase, DbReadBase, UpdateCallback, Callback):
from gramps.plugins.export.exportxml import XmlWriter
from gramps.cli.user import User
writer = XmlWriter(self, User(), strip_photos=0, compress=1)
filename = os.path.join(self._directory, "data.gramps")
timestamp = '{0:%Y-%m-%d-%H-%M-%S}'.format(datetime.datetime.now())
filename = os.path.join(self._directory, "backup-%s.gramps" % timestamp)
writer.write(filename)
def get_undodb(self):

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

@ -190,8 +190,8 @@ def diff_dbs(db1, db2, user=None):
for item in ['Person', 'Family', 'Source', 'Citation', 'Event', 'Media',
'Place', 'Repository', 'Note', 'Tag']:
step()
handles1 = sorted([handle.decode('utf-8') for handle in db1._tables[item]["handles_func"]()])
handles2 = sorted([handle.decode('utf-8') for handle in db2._tables[item]["handles_func"]()])
handles1 = sorted([handle for handle in db1._tables[item]["handles_func"]()])
handles2 = sorted([handle for handle in db2._tables[item]["handles_func"]()])
p1 = 0
p2 = 0
while p1 < len(handles1) and p2 < len(handles2):

89
gramps/plugins/database/dbapi.py
View File

@ -336,17 +336,17 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle FROM person;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_family_handles(self):
self.dbapi.execute("SELECT handle FROM family;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_event_handles(self):
self.dbapi.execute("SELECT handle FROM event;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_citation_handles(self, sort_handles=False):
if sort_handles:
@ -354,7 +354,7 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle FROM citation;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_source_handles(self, sort_handles=False):
if sort_handles:
@ -362,7 +362,7 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle from source;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_place_handles(self, sort_handles=False):
if sort_handles:
@ -370,12 +370,12 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle FROM place;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_repository_handles(self):
self.dbapi.execute("SELECT handle FROM repository;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_media_handles(self, sort_handles=False):
if sort_handles:
@ -383,12 +383,12 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle FROM media;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_note_handles(self):
self.dbapi.execute("SELECT handle FROM note;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_tag_handles(self, sort_handles=False):
if sort_handles:
@ -396,7 +396,7 @@ class DBAPI(DbGeneric):
else:
self.dbapi.execute("SELECT handle FROM tag;")
rows = self.dbapi.fetchall()
return [row[0] for row in rows]
return [bytes(row[0], "utf-8") for row in rows]
def get_tag_from_name(self, name):
self.dbapi.execute("""select handle from tag where order_by = ?;""",
@ -960,7 +960,8 @@ class DBAPI(DbGeneric):
Remove the Person specified by the database handle from the database,
preserving the change in the passed transaction.
"""
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
if self.readonly or not handle:
return
if handle in self.person_map:
@ -973,6 +974,8 @@ class DBAPI(DbGeneric):
person.serialize(), None)
def _do_remove(self, handle, transaction, data_map, data_id_map, key):
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
key2table = {
PERSON_KEY: "person",
FAMILY_KEY: "family",
@ -1013,6 +1016,8 @@ class DBAPI(DbGeneric):
result_list = list(find_backlink_handles(handle))
"""
if isinstance(handle, bytes):
handle = str(handle, "utf-8")
self.dbapi.execute("SELECT obj_class, obj_handle FROM reference WHERE ref_handle = ?;",
[handle])
rows = self.dbapi.fetchall()
@ -1082,61 +1087,61 @@ class DBAPI(DbGeneric):
self.dbapi.execute("SELECT handle FROM person;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_family_handles(self):
self.dbapi.execute("SELECT handle FROM family;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_citation_handles(self):
self.dbapi.execute("SELECT handle FROM citation;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_event_handles(self):
self.dbapi.execute("SELECT handle FROM event;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_media_handles(self):
self.dbapi.execute("SELECT handle FROM media;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_note_handles(self):
self.dbapi.execute("SELECT handle FROM note;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_place_handles(self):
self.dbapi.execute("SELECT handle FROM place;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_repository_handles(self):
self.dbapi.execute("SELECT handle FROM repository;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_source_handles(self):
self.dbapi.execute("SELECT handle FROM source;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def iter_tag_handles(self):
self.dbapi.execute("SELECT handle FROM tag;")
rows = self.dbapi.fetchall()
for row in rows:
yield row[0]
yield bytes(row[0], "utf-8")
def reindex_reference_map(self, callback):
callback(4)
@ -1188,42 +1193,62 @@ class DBAPI(DbGeneric):
self.dbapi.commit()
def has_handle_for_person(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM person WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_family(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM family WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_source(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM source WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_citation(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM citation WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_event(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM event WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_media(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM media WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_place(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM place WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_repository(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM repository WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_note(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM note WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
def has_handle_for_tag(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT 1 FROM tag WHERE handle = ?", [key])
return self.dbapi.fetchone() != None
@ -1309,6 +1334,8 @@ class DBAPI(DbGeneric):
return [row[0] for row in rows]
def _get_raw_person_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM person WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1321,6 +1348,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_family_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM family WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1333,6 +1362,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_source_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM source WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1345,6 +1376,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_citation_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM citation WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1357,6 +1390,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_event_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM event WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1369,6 +1404,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_media_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM media WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1381,6 +1418,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_place_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM place WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1393,18 +1432,24 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_repository_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM repository WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
return pickle.loads(row[0])
def _get_raw_repository_from_id_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM repository WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
return pickle.loads(row[0])
def _get_raw_note_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM note WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:
@ -1417,6 +1462,8 @@ class DBAPI(DbGeneric):
return pickle.loads(row[0])
def _get_raw_tag_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
self.dbapi.execute("SELECT blob_data FROM tag WHERE handle = ?", [key])
row = self.dbapi.fetchone()
if row:

82
gramps/plugins/database/dictionarydb.py
View File

@ -128,39 +128,39 @@ class DictionaryDb(DbGeneric):
def get_person_handles(self, sort_handles=False):
## Fixme: implement sort
return self._person_dict.keys()
return [bytes(key, "utf-8") for key in self._person_dict.keys()]
def get_family_handles(self):
return self._family_dict.keys()
return [bytes(key, "utf-8") for key in self._family_dict.keys()]
def get_event_handles(self):
return self._event_dict.keys()
return [bytes(key, "utf-8") for key in self._event_dict.keys()]
def get_citation_handles(self, sort_handles=False):
## Fixme: implement sort
return self._citation_dict.keys()
return [bytes(key, "utf-8") for key in self._citation_dict.keys()]
def get_source_handles(self, sort_handles=False):
## Fixme: implement sort
return self._source_dict.keys()
return [bytes(key, "utf-8") for key in self._source_dict.keys()]
def get_place_handles(self, sort_handles=False):
## Fixme: implement sort
return self._place_dict.keys()
return [bytes(key, "utf-8") for key in self._place_dict.keys()]
def get_repository_handles(self):
return self._repository_dict.keys()
return [bytes(key, "utf-8") for key in self._repository_dict.keys()]
def get_media_handles(self, sort_handles=False):
## Fixme: implement sort
return self._media_dict.keys()
return [bytes(key, "utf-8") for key in self._media_dict.keys()]
def get_note_handles(self):
return self._note_dict.keys()
return [bytes(key, "utf-8") for key in self._note_dict.keys()]
def get_tag_handles(self, sort_handles=False):
# FIXME: implement sort
return self._tag_dict.keys()
return [bytes(key, "utf-8") for key in self._tag_dict.keys()]
def get_tag_from_name(self, name):
return self._tag_name_dict.get(name, None)
@ -636,6 +636,8 @@ class DictionaryDb(DbGeneric):
result_list = list(find_backlink_handles(handle))
"""
if isinstance(handle, bytes):
key = str(handle, "utf-8")
#self._reference_list = [[obj.handle,
# obj.__class__.__name__,
# ref_handle,
@ -656,34 +658,34 @@ class DictionaryDb(DbGeneric):
return list(self._person_dict.values())[0]
def iter_person_handles(self):
return (handle for handle in self._person_dict.keys())
return (bytes(handle, "utf-8") for handle in self._person_dict.keys())
def iter_family_handles(self):
return (handle for handle in self._family_dict.keys())
return (bytes(handle, "utf-8") for handle in self._family_dict.keys())
def iter_citation_handles(self):
return (key for key in self._citation_dict.keys())
return (bytes(key, "utf-8") for key in self._citation_dict.keys())
def iter_event_handles(self):
return (key for key in self._event_dict.keys())
return (bytes(key, "utf-8") for key in self._event_dict.keys())
def iter_media_handles(self):
return (key for key in self._media_dict.keys())
return (bytes(key, "utf-8") for key in self._media_dict.keys())
def iter_note_handles(self):
return (key for key in self._note_dict.keys())
return (bytes(key, "utf-8") for key in self._note_dict.keys())
def iter_place_handles(self):
return (key for key in self._place_dict.keys())
return (bytes(key, "utf-8") for key in self._place_dict.keys())
def iter_repository_handles(self):
return (key for key in self._repository_dict.keys())
return (bytes(key, "utf-8") for key in self._repository_dict.keys())
def iter_source_handles(self):
return (key for key in self._source_dict.keys())
return (bytes(key, "utf-8") for key in self._source_dict.keys())
def iter_tag_handles(self):
return (key for key in self._tag_dict.keys())
return (bytes(key, "utf-8") for key in self._tag_dict.keys())
def reindex_reference_map(self, callback):
callback(4)
@ -723,33 +725,53 @@ class DictionaryDb(DbGeneric):
self.surname_list = self.build_surname_list()
def has_handle_for_person(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._person_dict
def has_handle_for_family(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._family_dict
def has_handle_for_source(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._source_dict
def has_handle_for_citation(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._citation_dict
def has_handle_for_event(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._event_dict
def has_handle_for_media(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._media_dict
def has_handle_for_place(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._place_dict
def has_handle_for_repository(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._repository_dict
def has_handle_for_note(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._note_dict
def has_handle_for_tag(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
return key in self._tag_dict
def has_gramps_id_for_person(self, key):
@ -807,6 +829,8 @@ class DictionaryDb(DbGeneric):
return [x.gramps_id for x in self._note_dict.values()]
def _get_raw_person_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._person_dict:
return self._person_dict[key].serialize()
@ -815,6 +839,8 @@ class DictionaryDb(DbGeneric):
return self._person_id_dict[key].serialize()
def _get_raw_family_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._family_dict:
return self._family_dict[key].serialize()
@ -823,6 +849,8 @@ class DictionaryDb(DbGeneric):
return self._family_id_dict[key].serialize()
def _get_raw_source_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._source_dict:
return self._source_dict[key].serialize()
@ -831,6 +859,8 @@ class DictionaryDb(DbGeneric):
return self._source_id_dict[key].serialize()
def _get_raw_citation_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._citation_dict:
return self._citation_dict[key].serialize()
@ -839,6 +869,8 @@ class DictionaryDb(DbGeneric):
return self._citation_id_dict[key].serialize()
def _get_raw_event_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._event_dict:
return self._event_dict[key].serialize()
@ -847,6 +879,8 @@ class DictionaryDb(DbGeneric):
return self._event_id_dict[key].serialize()
def _get_raw_media_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._media_dict:
return self._media_dict[key].serialize()
@ -855,6 +889,8 @@ class DictionaryDb(DbGeneric):
return self._media_id_dict[key].serialize()
def _get_raw_place_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._place_dict:
return self._place_dict[key].serialize()
@ -863,6 +899,8 @@ class DictionaryDb(DbGeneric):
return self._place_id_dict[key].serialize()
def _get_raw_repository_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._repository_dict:
return self._repository_dict[key].serialize()
@ -871,6 +909,8 @@ class DictionaryDb(DbGeneric):
return self._repository_id_dict[key].serialize()
def _get_raw_note_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._note_dict:
return self._note_dict[key].serialize()
@ -879,6 +919,8 @@ class DictionaryDb(DbGeneric):
return self._note_id_dict[key].serialize()
def _get_raw_tag_data(self, key):
if isinstance(key, bytes):
key = str(key, "utf-8")
if key in self._tag_dict:
return self._tag_dict[key].serialize()