From 403c87b8873d002618f0916c27eda99a22fb478d Mon Sep 17 00:00:00 2001 From: Doug Blank Date: Sun, 31 Jan 2016 09:15:52 -0500 Subject: [PATCH] DB-API and DbDictionary both use same binary handles as BSDDB --- gramps/gen/db/generic.py | 58 ++++++++++++++-- gramps/gen/merge/diff.py | 4 +- gramps/plugins/database/dbapi.py | 89 +++++++++++++++++++------ gramps/plugins/database/dictionarydb.py | 82 +++++++++++++++++------ 4 files changed, 183 insertions(+), 50 deletions(-) diff --git a/gramps/gen/db/generic.py b/gramps/gen/db/generic.py index ca9dedc7c..916c7ae19 100644 --- a/gramps/gen/db/generic.py +++ b/gramps/gen/db/generic.py @@ -1,7 +1,7 @@ # # Gramps - a GTK+/GNOME based genealogy program # -# Copyright (C) 2015 Douglas S. Blank +# 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): diff --git a/gramps/gen/merge/diff.py b/gramps/gen/merge/diff.py index 7ffd531a0..3eb0d95cd 100644 --- a/gramps/gen/merge/diff.py +++ b/gramps/gen/merge/diff.py @@ -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): diff --git a/gramps/plugins/database/dbapi.py b/gramps/plugins/database/dbapi.py index 33784dfe0..b36304e29 100644 --- a/gramps/plugins/database/dbapi.py +++ b/gramps/plugins/database/dbapi.py @@ -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: diff --git a/gramps/plugins/database/dictionarydb.py b/gramps/plugins/database/dictionarydb.py index 6bdbd735b..3641b77a5 100644 --- a/gramps/plugins/database/dictionarydb.py +++ b/gramps/plugins/database/dictionarydb.py @@ -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()