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

gramps/gen/db/generic.py

@@ -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):

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"]()])
+            handles1 = sorted([handle for handle in db1._tables[item]["handles_func"]()])
-            handles2 = sorted([handle.decode('utf-8') for handle in db2._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):

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:

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()