In preparation for Python 3 support, use the Python 2 PyBytes aliases for the

PyString API.  This makes the code compilable in Python 2.x (x >= 6) and
Python 3.

12 files changed, 129 insertions, 115 deletions

diff --git a/_dbus_bindings/abstract.c b/_dbus_bindings/abstract.c
index 7683fbe..af2ea8e 100644
--- a/_dbus_bindings/abstract.c
+++ b/_dbus_bindings/abstract.c
@@ -95,7 +95,7 @@ dbus_py_variant_level_getattro(PyObject *obj, PyObject *name)
 {
     PyObject *key, *value;
 
-    if (PyString_Check(name)) {
+    if (PyBytes_Check(name)) {
         Py_INCREF(name);
     }
     else if (PyUnicode_Check(name)) {
@@ -109,7 +109,7 @@ dbus_py_variant_level_getattro(PyObject *obj, PyObject *name)
         return NULL;
     }
 
-    if (strcmp(PyString_AS_STRING(name), "variant_level")) {
+    if (strcmp(PyBytes_AS_STRING(name), "variant_level")) {
         value = PyObject_GenericGetAttr(obj, name);
         Py_CLEAR(name);
         return value;
@@ -394,7 +394,7 @@ DBusPythonString_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
         return NULL;
     }
 
-    self = (PyString_Type.tp_new)(cls, args, NULL);
+    self = (PyBytes_Type.tp_new)(cls, args, NULL);
     if (self) {
         if (!dbus_py_variant_level_set(self, variantness)) {
             Py_CLEAR(self);
@@ -407,7 +407,7 @@ DBusPythonString_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 static PyObject *
 DBusPythonString_tp_repr(PyObject *self)
 {
-    PyObject *parent_repr = (PyString_Type.tp_repr)(self);
+    PyObject *parent_repr = (PyBytes_Type.tp_repr)(self);
     PyObject *vl_obj;
     PyObject *my_repr;
     long variant_level;
@@ -439,7 +439,7 @@ static void
 DBusPyStrBase_tp_dealloc(PyObject *self)
 {
     dbus_py_variant_level_clear(self);
-    (PyString_Type.tp_dealloc)(self);
+    (PyBytes_Type.tp_dealloc)(self);
 }
 
 PyTypeObject DBusPyStrBase_Type = {
@@ -473,7 +473,7 @@ PyTypeObject DBusPyStrBase_Type = {
     0,                                      /* tp_methods */
     0,                                      /* tp_members */
     0,                                      /* tp_getset */
-    DEFERRED_ADDRESS(&PyString_Type),       /* tp_base */
+    DEFERRED_ADDRESS(&PyBytes_Type),        /* tp_base */
     0,                                      /* tp_dict */
     0,                                      /* tp_descr_get */
     0,                                      /* tp_descr_set */
@@ -610,13 +610,14 @@ dbus_py_init_abstract(void)
     _dbus_py_variant_levels = PyDict_New();
     if (!_dbus_py_variant_levels) return 0;
 
-    dbus_py__dbus_object_path__const = PyString_InternFromString("__dbus_object_path__");
+    dbus_py__dbus_object_path__const =
+        PyBytes_InternFromString("__dbus_object_path__");
     if (!dbus_py__dbus_object_path__const) return 0;
 
-    dbus_py_variant_level_const = PyString_InternFromString("variant_level");
+    dbus_py_variant_level_const = PyBytes_InternFromString("variant_level");
     if (!dbus_py_variant_level_const) return 0;
 
-    dbus_py_signature_const = PyString_InternFromString("signature");
+    dbus_py_signature_const = PyBytes_InternFromString("signature");
     if (!dbus_py_signature_const) return 0;
 
     DBusPyIntBase_Type.tp_base = &PyInt_Type;
@@ -633,7 +634,7 @@ dbus_py_init_abstract(void)
     if (PyType_Ready(&DBusPyLongBase_Type) < 0) return 0;
     DBusPyLongBase_Type.tp_print = NULL;
 
-    DBusPyStrBase_Type.tp_base = &PyString_Type;
+    DBusPyStrBase_Type.tp_base = &PyBytes_Type;
     if (PyType_Ready(&DBusPyStrBase_Type) < 0) return 0;
     DBusPyStrBase_Type.tp_print = NULL;
 
diff --git a/_dbus_bindings/bus.c b/_dbus_bindings/bus.c
index 0ffe62b..cc9294a 100644
--- a/_dbus_bindings/bus.c
+++ b/_dbus_bindings/bus.c
@@ -42,7 +42,7 @@ DBusPyConnection_NewForBus(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 
     dbus_error_init(&error);
 
-    if (first && PyString_Check(first)) {
+    if (first && PyBytes_Check(first)) {
         dbus_bool_t ret;
 
         /* It's a custom address. First connect to it, then register. */
@@ -142,7 +142,7 @@ DBusPyConnection_GetUniqueName(Connection *self, PyObject *args UNUSED)
         return DBusPyException_SetString("This connection has no unique name "
                                          "yet");
     }
-    return PyString_FromString(name);
+    return PyBytes_FromString(name);
 }
 
 PyObject *
diff --git a/_dbus_bindings/bytes.c b/_dbus_bindings/bytes.c
index e06dcd1..e608ec2 100644
--- a/_dbus_bindings/bytes.c
+++ b/_dbus_bindings/bytes.c
@@ -79,12 +79,12 @@ Byte_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
     /* obj is only a borrowed ref for the moment */
     obj = PyTuple_GetItem(args, 0);
 
-    if (PyString_Check(obj)) {
+    if (PyBytes_Check(obj)) {
         /* string of length 1, we hope */
-        if (PyString_GET_SIZE(obj) != 1) {
+        if (PyBytes_GET_SIZE(obj) != 1) {
             goto bad_arg;
         }
-        obj = PyInt_FromLong((unsigned char)(PyString_AS_STRING(obj)[0]));
+        obj = PyInt_FromLong((unsigned char)(PyBytes_AS_STRING(obj)[0]));
     }
     else if (PyInt_Check(obj)) {
         long i = PyInt_AS_LONG(obj);
@@ -123,7 +123,7 @@ static PyObject *
 Byte_tp_str(PyObject *self)
 {
     unsigned char str[2] = { (unsigned char)PyInt_AS_LONG(self), 0 };
-    return PyString_FromStringAndSize((char *)str, 1);
+    return PyBytes_FromStringAndSize((char *)str, 1);
 }
 
 PyTypeObject DBusPyByte_Type = {
diff --git a/_dbus_bindings/conn-methods.c b/_dbus_bindings/conn-methods.c
index 93fb7a7..d2ebeb1 100644
--- a/_dbus_bindings/conn-methods.c
+++ b/_dbus_bindings/conn-methods.c
@@ -40,8 +40,9 @@ _object_path_unregister(DBusConnection *conn, void *user_data)
     TRACE(conn_obj);
 
     DBG("Connection at %p unregistering object path %s",
-        conn_obj, PyString_AS_STRING((PyObject *)user_data));
-    tuple = DBusPyConnection_GetObjectPathHandlers((PyObject *)conn_obj, (PyObject *)user_data);
+        conn_obj, PyBytes_AS_STRING((PyObject *)user_data));
+    tuple = DBusPyConnection_GetObjectPathHandlers(
+        (PyObject *)conn_obj, (PyObject *)user_data);
     if (!tuple) goto out;
     if (tuple == Py_None) goto out;
 
@@ -91,9 +92,10 @@ _object_path_message(DBusConnection *conn, DBusMessage *message,
     TRACE(conn_obj);
 
     DBG("Connection at %p messaging object path %s",
-        conn_obj, PyString_AS_STRING((PyObject *)user_data));
+        conn_obj, PyBytes_AS_STRING((PyObject *)user_data));
     DBG_DUMP_MESSAGE(message);
-    tuple = DBusPyConnection_GetObjectPathHandlers((PyObject *)conn_obj, (PyObject *)user_data);
+    tuple = DBusPyConnection_GetObjectPathHandlers(
+        (PyObject *)conn_obj, (PyObject *)user_data);
     if (!tuple || tuple == Py_None) {
         ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
         goto out;
@@ -724,15 +726,15 @@ Connection__register_object_path(Connection *self, PyObject *args,
     mad) to preserve the desirable property that the DBusConnection can
     never strongly reference the Connection, even indirectly.
     */
-    if (PyString_CheckExact(path)) {
+    if (PyBytes_CheckExact(path)) {
         Py_INCREF(path);
     }
     else if (PyUnicode_Check(path)) {
         path = PyUnicode_AsUTF8String(path);
         if (!path) return NULL;
     }
-    else if (PyString_Check(path)) {
-        path = PyString_FromString(PyString_AS_STRING(path));
+    else if (PyBytes_Check(path)) {
+        path = PyBytes_FromString(PyBytes_AS_STRING(path));
         if (!path) return NULL;
     }
     else {
@@ -740,7 +742,7 @@ Connection__register_object_path(Connection *self, PyObject *args,
         return NULL;
     }
 
-    if (!dbus_py_validate_object_path(PyString_AS_STRING(path))) {
+    if (!dbus_py_validate_object_path(PyBytes_AS_STRING(path))) {
         Py_CLEAR(path);
         return NULL;
     }
@@ -756,7 +758,7 @@ Connection__register_object_path(Connection *self, PyObject *args,
     if (callbacks && callbacks != Py_None) {
         PyErr_Format(PyExc_KeyError, "Can't register the object-path "
                      "handler for '%s': there is already a handler",
-                     PyString_AS_STRING(path));
+                     PyBytes_AS_STRING(path));
         Py_CLEAR(tuple);
         Py_CLEAR(path);
         return NULL;
@@ -775,13 +777,13 @@ Connection__register_object_path(Connection *self, PyObject *args,
     Py_BEGIN_ALLOW_THREADS
     if (fallback) {
         ok = dbus_connection_register_fallback(self->conn,
-                                               PyString_AS_STRING(path),
+                                               PyBytes_AS_STRING(path),
                                                &_object_path_vtable,
                                                path);
     }
     else {
         ok = dbus_connection_register_object_path(self->conn,
-                                                  PyString_AS_STRING(path),
+                                                  PyBytes_AS_STRING(path),
                                                   &_object_path_vtable,
                                                   path);
     }
@@ -795,7 +797,7 @@ Connection__register_object_path(Connection *self, PyObject *args,
             memory in libdbus, but tbh we should never get here anyway. */
             Py_BEGIN_ALLOW_THREADS
             ok = dbus_connection_unregister_object_path(self->conn,
-                                                    PyString_AS_STRING(path));
+                                                      PyBytes_AS_STRING(path));
             Py_END_ALLOW_THREADS
             return NULL;
         }
@@ -840,15 +842,15 @@ Connection__unregister_object_path(Connection *self, PyObject *args,
                                      argnames, &path)) return NULL;
 
     /* Take a ref to the path. Same comments as for _register_object_path. */
-    if (PyString_CheckExact(path)) {
+    if (PyBytes_CheckExact(path)) {
         Py_INCREF(path);
     }
     else if (PyUnicode_Check(path)) {
         path = PyUnicode_AsUTF8String(path);
         if (!path) return NULL;
     }
-    else if (PyString_Check(path)) {
-        path = PyString_FromString(PyString_AS_STRING(path));
+    else if (PyBytes_Check(path)) {
+        path = PyBytes_FromString(PyBytes_AS_STRING(path));
         if (!path) return NULL;
     }
     else {
@@ -862,7 +864,7 @@ Connection__unregister_object_path(Connection *self, PyObject *args,
     if (!callbacks || callbacks == Py_None) {
         PyErr_Format(PyExc_KeyError, "Can't unregister the object-path "
                      "handler for '%s': there is no such handler",
-                     PyString_AS_STRING(path));
+                     PyBytes_AS_STRING(path));
         Py_CLEAR(path);
         return NULL;
     }
@@ -898,7 +900,7 @@ Connection__unregister_object_path(Connection *self, PyObject *args,
 
     Py_BEGIN_ALLOW_THREADS
     ok = dbus_connection_unregister_object_path(self->conn,
-                                                PyString_AS_STRING(path));
+                                                PyBytes_AS_STRING(path));
     Py_END_ALLOW_THREADS
 
     if (ok) {
@@ -968,7 +970,7 @@ Connection_list_exported_child_objects (Connection *self, PyObject *args,
         return NULL;
     }
     for (kid_ptr = kids; *kid_ptr; kid_ptr++) {
-        PyObject *tmp = PyString_FromString(*kid_ptr);
+        PyObject *tmp = PyBytes_FromString(*kid_ptr);
 
         if (!tmp) {
             Py_CLEAR(ret);
@@ -988,7 +990,7 @@ Connection_list_exported_child_objects (Connection *self, PyObject *args,
 }
 
     /* dbus_connection_get_object_path_data - not useful to Python,
-     * the object path data is just a PyString containing the path */
+     * the object path data is just a PyBytes containing the path */
     /* dbus_connection_list_registered could be useful, though */
 
 /* dbus_connection_set_change_sigpipe - sets global state */
diff --git a/_dbus_bindings/conn.c b/_dbus_bindings/conn.c
index 2e40bac..1cc6858 100644
--- a/_dbus_bindings/conn.c
+++ b/_dbus_bindings/conn.c
@@ -318,7 +318,7 @@ Connection_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 
         conn = dbus_connection_ref (wrapper->conn);
     }
-    else if ((address = PyString_AsString(address_or_conn)) != NULL) {
+    else if ((address = PyBytes_AsString(address_or_conn)) != NULL) {
         dbus_error_init(&error);
 
         /* We always open a private connection (at the libdbus level). Sharing
diff --git a/_dbus_bindings/containers.c b/_dbus_bindings/containers.c
index bc07f12..f74476c 100644
--- a/_dbus_bindings/containers.c
+++ b/_dbus_bindings/containers.c
@@ -166,7 +166,7 @@ Array_tp_init (DBusPyArray *self, PyObject *args, PyObject *kwargs)
     }
 
     if (signature != Py_None) {
-        const char *c_str = PyString_AS_STRING(signature);
+        const char *c_str = PyBytes_AS_STRING(signature);
 
         if (!dbus_signature_validate_single(c_str, NULL)) {
             Py_CLEAR(signature);
@@ -372,7 +372,7 @@ Dict_tp_init(DBusPyDict *self, PyObject *args, PyObject *kwargs)
     }
 
     if (signature != Py_None) {
-        const char *c_str = PyString_AS_STRING(signature);
+        const char *c_str = PyBytes_AS_STRING(signature);
 
         switch (c_str[0]) {
             case DBUS_TYPE_BYTE:
@@ -646,7 +646,7 @@ Struct_tp_getattro(PyObject *obj, PyObject *name)
 {
     PyObject *key, *value;
 
-    if (PyString_Check(name)) {
+    if (PyBytes_Check(name)) {
         Py_INCREF(name);
     }
     else if (PyUnicode_Check(name)) {
@@ -660,7 +660,7 @@ Struct_tp_getattro(PyObject *obj, PyObject *name)
         return NULL;
     }
 
-    if (strcmp(PyString_AS_STRING(name), "signature")) {
+    if (strcmp(PyBytes_AS_STRING(name), "signature")) {
         value = dbus_py_variant_level_getattro(obj, name);
         Py_CLEAR(name);
         return value;
diff --git a/_dbus_bindings/exceptions.c b/_dbus_bindings/exceptions.c
index fe09620..e515130 100644
--- a/_dbus_bindings/exceptions.c
+++ b/_dbus_bindings/exceptions.c
@@ -37,7 +37,7 @@ import_exception(void)
         return TRUE;
     }
 
-    name = PyString_FromString("dbus.exceptions");
+    name = PyBytes_FromString("dbus.exceptions");
     if (name == NULL) {
         return FALSE;
     }
@@ -81,7 +81,7 @@ DBusPyException_ConsumeError(DBusError *error)
     }
 
     if (error->name) {
-        PyObject *name = PyString_FromString(error->name);
+        PyObject *name = PyBytes_FromString(error->name);
         int ret;
 
         if (!name)
diff --git a/_dbus_bindings/message-append.c b/_dbus_bindings/message-append.c
index 32adb51..587195f 100644
--- a/_dbus_bindings/message-append.c
+++ b/_dbus_bindings/message-append.c
@@ -143,7 +143,7 @@ get_object_path(PyObject *obj)
     PyObject *magic_attr = PyObject_GetAttr(obj, dbus_py__dbus_object_path__const);
 
     if (magic_attr) {
-        if (PyString_Check(magic_attr)) {
+        if (PyBytes_Check(magic_attr)) {
             return magic_attr;
         }
         else {
@@ -175,11 +175,11 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
         *variant_level_ptr = variant_level;
     }
     else if (variant_level > 0) {
-        return PyString_FromString(DBUS_TYPE_VARIANT_AS_STRING);
+        return PyBytes_FromString(DBUS_TYPE_VARIANT_AS_STRING);
     }
 
     if (obj == Py_True || obj == Py_False) {
-      return PyString_FromString(DBUS_TYPE_BOOLEAN_AS_STRING);
+      return PyBytes_FromString(DBUS_TYPE_BOOLEAN_AS_STRING);
     }
 
     magic_attr = get_object_path(obj);
@@ -187,61 +187,61 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
         return NULL;
     if (magic_attr != Py_None) {
         Py_CLEAR(magic_attr);
-        return PyString_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING);
+        return PyBytes_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING);
     }
     Py_CLEAR(magic_attr);
 
     /* Ordering is important: some of these are subclasses of each other. */
     if (PyInt_Check(obj)) {
         if (DBusPyInt16_Check(obj))
-            return PyString_FromString(DBUS_TYPE_INT16_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_INT16_AS_STRING);
         else if (DBusPyInt32_Check(obj))
-            return PyString_FromString(DBUS_TYPE_INT32_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_INT32_AS_STRING);
         else if (DBusPyByte_Check(obj))
-            return PyString_FromString(DBUS_TYPE_BYTE_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_BYTE_AS_STRING);
         else if (DBusPyUInt16_Check(obj))
-            return PyString_FromString(DBUS_TYPE_UINT16_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_UINT16_AS_STRING);
         else if (DBusPyBoolean_Check(obj))
-            return PyString_FromString(DBUS_TYPE_BOOLEAN_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_BOOLEAN_AS_STRING);
         else
-            return PyString_FromString(DBUS_TYPE_INT32_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_INT32_AS_STRING);
     }
     else if (PyLong_Check(obj)) {
         if (DBusPyInt64_Check(obj))
-            return PyString_FromString(DBUS_TYPE_INT64_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_INT64_AS_STRING);
         else if (DBusPyUInt32_Check(obj))
-            return PyString_FromString(DBUS_TYPE_UINT32_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_UINT32_AS_STRING);
         else if (DBusPyUInt64_Check(obj))
-            return PyString_FromString(DBUS_TYPE_UINT64_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_UINT64_AS_STRING);
         else
-            return PyString_FromString(DBUS_TYPE_INT64_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_INT64_AS_STRING);
     }
     else if (PyUnicode_Check(obj))
-        return PyString_FromString(DBUS_TYPE_STRING_AS_STRING);
+        return PyBytes_FromString(DBUS_TYPE_STRING_AS_STRING);
 #if defined(DBUS_TYPE_UNIX_FD)
     else if (DBusPyUnixFd_Check(obj))
-        return PyString_FromString(DBUS_TYPE_UNIX_FD_AS_STRING);
+        return PyBytes_FromString(DBUS_TYPE_UNIX_FD_AS_STRING);
 #endif
     else if (PyFloat_Check(obj)) {
 #ifdef WITH_DBUS_FLOAT32
         if (DBusPyDouble_Check(obj))
-            return PyString_FromString(DBUS_TYPE_DOUBLE_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_DOUBLE_AS_STRING);
         else if (DBusPyFloat_Check(obj))
-            return PyString_FromString(DBUS_TYPE_FLOAT_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_FLOAT_AS_STRING);
         else
 #endif
-            return PyString_FromString(DBUS_TYPE_DOUBLE_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_DOUBLE_AS_STRING);
     }
-    else if (PyString_Check(obj)) {
+    else if (PyBytes_Check(obj)) {
         if (DBusPyObjectPath_Check(obj))
-            return PyString_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING);
         else if (DBusPySignature_Check(obj))
-            return PyString_FromString(DBUS_TYPE_SIGNATURE_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_SIGNATURE_AS_STRING);
         else if (DBusPyByteArray_Check(obj))
-            return PyString_FromString(DBUS_TYPE_ARRAY_AS_STRING
-                                       DBUS_TYPE_BYTE_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_ARRAY_AS_STRING
+                                      DBUS_TYPE_BYTE_AS_STRING);
         else
-            return PyString_FromString(DBUS_TYPE_STRING_AS_STRING);
+            return PyBytes_FromString(DBUS_TYPE_STRING_AS_STRING);
     }
     else if (PyTuple_Check(obj)) {
         Py_ssize_t len = PyTuple_GET_SIZE(obj);
@@ -258,12 +258,12 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
             return NULL;
         }
         /* Set the first and last elements of list to be the parentheses */
-        item = PyString_FromString(DBUS_STRUCT_BEGIN_CHAR_AS_STRING);
+        item = PyBytes_FromString(DBUS_STRUCT_BEGIN_CHAR_AS_STRING);
         if (PyList_SetItem(list, 0, item) < 0) {
             Py_CLEAR(list);
             return NULL;
         }
-        item = PyString_FromString(DBUS_STRUCT_END_CHAR_AS_STRING);
+        item = PyBytes_FromString(DBUS_STRUCT_END_CHAR_AS_STRING);
         if (PyList_SetItem(list, len + 1, item) < 0) {
             Py_CLEAR(list);
             return NULL;
@@ -291,7 +291,7 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
             }
             item = NULL;
         }
-        empty_str = PyString_FromString("");
+        empty_str = PyBytes_FromString("");
         if (!empty_str) {
             /* really shouldn't happen */
             Py_CLEAR(list);
@@ -305,10 +305,12 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
     }
     else if (PyList_Check(obj)) {
         PyObject *tmp;
-        PyObject *ret = PyString_FromString(DBUS_TYPE_ARRAY_AS_STRING);
+        PyObject *ret = PyBytes_FromString(DBUS_TYPE_ARRAY_AS_STRING);
         if (!ret) return NULL;
-        if (DBusPyArray_Check(obj) && PyString_Check(((DBusPyArray *)obj)->signature)) {
-            PyString_Concat(&ret, ((DBusPyArray *)obj)->signature);
+        if (DBusPyArray_Check(obj) &&
+            PyBytes_Check(((DBusPyArray *)obj)->signature))
+        {
+            PyBytes_Concat(&ret, ((DBusPyArray *)obj)->signature);
             return ret;
         }
         if (PyList_GET_SIZE(obj) == 0) {
@@ -320,7 +322,7 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
         tmp = PyList_GetItem(obj, 0);
         tmp = _signature_string_from_pyobject(tmp, NULL);
         if (!tmp) return NULL;
-        PyString_ConcatAndDel(&ret, tmp);
+        PyBytes_ConcatAndDel(&ret, tmp);
         return ret;
     }
     else if (PyDict_Check(obj)) {
@@ -328,14 +330,16 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
         Py_ssize_t pos = 0;
         PyObject *ret = NULL;
 
-        if (DBusPyDict_Check(obj) && PyString_Check(((DBusPyDict *)obj)->signature)) {
-            const char *sig = PyString_AS_STRING(((DBusPyDict *)obj)->signature);
+        if (DBusPyDict_Check(obj) &&
+            PyBytes_Check(((DBusPyDict *)obj)->signature))
+        {
+            const char *sig = PyBytes_AS_STRING(((DBusPyDict *)obj)->signature);
 
-            return PyString_FromFormat((DBUS_TYPE_ARRAY_AS_STRING
-                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-                                        "%s"
-                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
-                                       sig);
+            return PyBytes_FromFormat((DBUS_TYPE_ARRAY_AS_STRING
+                                       DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+                                       "%s"
+                                       DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+                                      sig);
         }
         if (!PyDict_Next(obj, &pos, &key, &value)) {
             /* No items, so fail. Or should we guess "a{vv}"? */
@@ -346,12 +350,12 @@ _signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr)
         keysig = _signature_string_from_pyobject(key, NULL);
         valuesig = _signature_string_from_pyobject(value, NULL);
         if (keysig && valuesig) {
-            ret = PyString_FromFormat((DBUS_TYPE_ARRAY_AS_STRING
-                                       DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-                                       "%s%s"
-                                       DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
-                                      PyString_AS_STRING(keysig),
-                                      PyString_AS_STRING(valuesig));
+            ret = PyBytes_FromFormat((DBUS_TYPE_ARRAY_AS_STRING
+                                      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+                                      "%s%s"
+                                      DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+                                     PyBytes_AS_STRING(keysig),
+                                     PyBytes_AS_STRING(valuesig));
         }
         Py_CLEAR(keysig);
         Py_CLEAR(valuesig);
@@ -403,7 +407,7 @@ dbus_py_Message_guess_signature(PyObject *unused UNUSED, PyObject *args)
         DBG("%s", "Message_guess_signature: failed");
         return NULL;
     }
-    if (!PyString_Check(tmp) || PyString_GET_SIZE(tmp) < 2) {
+    if (!PyBytes_Check(tmp) || PyBytes_GET_SIZE(tmp) < 2) {
         PyErr_SetString(PyExc_RuntimeError, "Internal error: "
                         "_signature_string_from_pyobject returned "
                         "a bad result");
@@ -411,10 +415,10 @@ dbus_py_Message_guess_signature(PyObject *unused UNUSED, PyObject *args)
         return NULL;
     }
     ret = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "(s#)",
-                                PyString_AS_STRING(tmp) + 1,
-                                PyString_GET_SIZE(tmp) - 2);
+                                PyBytes_AS_STRING(tmp) + 1,
+                                PyBytes_GET_SIZE(tmp) - 2);
     DBG("Message_guess_signature: returning Signature at %p \"%s\"", ret,
-        ret ? PyString_AS_STRING(ret) : "(NULL)");
+        ret ? PyBytes_AS_STRING(ret) : "(NULL)");
     Py_CLEAR(tmp);
     return ret;
 }
@@ -450,13 +454,13 @@ _message_iter_append_string(DBusMessageIter *appender,
         }
     }
 
-    if (PyString_Check(obj)) {
+    if (PyBytes_Check(obj)) {
         PyObject *unicode;
 
         /* Raise TypeError if the string has embedded NULs */
-        if (PyString_AsStringAndSize(obj, &s, NULL) < 0) return -1;
+        if (PyBytes_AsStringAndSize(obj, &s, NULL) < 0) return -1;
         /* Surely there's a faster stdlib way to validate UTF-8... */
-        unicode = PyUnicode_DecodeUTF8(s, PyString_GET_SIZE(obj), NULL);
+        unicode = PyUnicode_DecodeUTF8(s, PyBytes_GET_SIZE(obj), NULL);
         if (!unicode) {
             PyErr_SetString(PyExc_UnicodeError, "String parameters "
                             "to be sent over D-Bus must be valid UTF-8");
@@ -475,7 +479,7 @@ _message_iter_append_string(DBusMessageIter *appender,
         PyObject *utf8 = PyUnicode_AsUTF8String(obj);
         if (!utf8) return -1;
         /* Raise TypeError if the string has embedded NULs */
-        if (PyString_AsStringAndSize(utf8, &s, NULL) < 0) return -1;
+        if (PyBytes_AsStringAndSize(utf8, &s, NULL) < 0) return -1;
         DBG("Performing actual append: string (from unicode) %s", s);
         if (!dbus_message_iter_append_basic(appender, sig_type, &s)) {
             Py_CLEAR(utf8);
@@ -497,14 +501,14 @@ _message_iter_append_byte(DBusMessageIter *appender, PyObject *obj)
 {
     unsigned char y;
 
-    if (PyString_Check(obj)) {
-        if (PyString_GET_SIZE(obj) != 1) {
+    if (PyBytes_Check(obj)) {
+        if (PyBytes_GET_SIZE(obj) != 1) {
             PyErr_Format(PyExc_ValueError, "Expected a string of "
                          "length 1 byte, but found %d bytes",
-                         (int) PyString_GET_SIZE(obj));
+                         (int) PyBytes_GET_SIZE(obj));
             return -1;
         }
-        y = *(unsigned char *)PyString_AS_STRING(obj);
+        y = *(unsigned char *)PyBytes_AS_STRING(obj);
     }
     else {
         long i = PyInt_AsLong(obj);
@@ -766,12 +770,12 @@ _message_iter_append_string_as_byte_array(DBusMessageIter *appender,
                                           PyObject *obj)
 {
     /* a bit of a faster path for byte arrays that are strings */
-    Py_ssize_t len = PyString_GET_SIZE(obj);
+    Py_ssize_t len = PyBytes_GET_SIZE(obj);
     const char *s;
     DBusMessageIter sub;
     int ret;
 
-    s = PyString_AS_STRING(obj);
+    s = PyBytes_AS_STRING(obj);
     DBG("%s", "Opening ARRAY container");
     if (!dbus_message_iter_open_container(appender, DBUS_TYPE_ARRAY,
                                           DBUS_TYPE_BYTE_AS_STRING, &sub)) {
@@ -810,7 +814,7 @@ _message_iter_append_variant(DBusMessageIter *appender, PyObject *obj)
     obj_sig = _signature_string_from_pyobject(obj, &variant_level);
     if (!obj_sig) return -1;
 
-    obj_sig_str = PyString_AsString(obj_sig);
+    obj_sig_str = PyBytes_AsString(obj_sig);
     if (!obj_sig_str) return -1;
 
     if (variant_level < 1) {
@@ -1028,7 +1032,7 @@ _message_iter_append_pyobject(DBusMessageIter *appender,
           if (sig_type == DBUS_TYPE_DICT_ENTRY)
             ret = _message_iter_append_multi(appender, sig_iter,
                                              DBUS_TYPE_DICT_ENTRY, obj);
-          else if (sig_type == DBUS_TYPE_BYTE && PyString_Check(obj))
+          else if (sig_type == DBUS_TYPE_BYTE && PyBytes_Check(obj))
             ret = _message_iter_append_string_as_byte_array(appender, obj);
           else
             ret = _message_iter_append_multi(appender, sig_iter,
@@ -1105,7 +1109,7 @@ dbus_py_Message_append(Message *self, PyObject *args, PyObject *kwargs)
         DBG("%s", "No signature for message, guessing...");
         signature_obj = dbus_py_Message_guess_signature(NULL, args);
         if (!signature_obj) return NULL;
-        signature = PyString_AS_STRING(signature_obj);
+        signature = PyBytes_AS_STRING(signature_obj);
     }
     /* from here onwards, you have to do a goto rather than returning NULL
     to make sure signature_obj gets freed */
diff --git a/_dbus_bindings/message.c b/_dbus_bindings/message.c
index e10d888..f96459f 100644
--- a/_dbus_bindings/message.c
+++ b/_dbus_bindings/message.c
@@ -415,7 +415,7 @@ Message_get_member(Message *self, PyObject *unused UNUSED)
     if (!c_str) {
         Py_RETURN_NONE;
     }
-    return PyString_FromString(c_str);
+    return PyBytes_FromString(c_str);
 }
 
 PyDoc_STRVAR(Message_has_member__doc__,
@@ -490,7 +490,7 @@ Message_get_path_decomposed(Message *self, PyObject *unused UNUSED)
         Py_RETURN_NONE;
     }
     for (ptr = paths; *ptr; ptr++) {
-        PyObject *str = PyString_FromString(*ptr);
+        PyObject *str = PyBytes_FromString(*ptr);
 
         if (!str) {
             Py_CLEAR(ret);
@@ -576,7 +576,7 @@ Message_get_sender(Message *self, PyObject *unused UNUSED)
     if (!c_str) {
         Py_RETURN_NONE;
     }
-    return PyString_FromString(c_str);
+    return PyBytes_FromString(c_str);
 }
 
 PyDoc_STRVAR(Message_has_sender__doc__,
@@ -622,7 +622,7 @@ Message_get_destination(Message *self, PyObject *unused UNUSED)
     if (!c_str) {
         Py_RETURN_NONE;
     }
-    return PyString_FromString(c_str);
+    return PyBytes_FromString(c_str);
 }
 
 PyDoc_STRVAR(Message_has_destination__doc__,
@@ -667,7 +667,7 @@ Message_get_interface(Message *self, PyObject *unused UNUSED)
     if (!c_str) {
         Py_RETURN_NONE;
     }
-    return PyString_FromString(c_str);
+    return PyBytes_FromString(c_str);
 }
 
 PyDoc_STRVAR(Message_has_interface__doc__,
@@ -712,7 +712,7 @@ Message_get_error_name(Message *self, PyObject *unused UNUSED)
     if (!c_str) {
         Py_RETURN_NONE;
     }
-    return PyString_FromString(c_str);
+    return PyBytes_FromString(c_str);
 }
 
 PyDoc_STRVAR(Message_set_error_name__doc__,
diff --git a/_dbus_bindings/server.c b/_dbus_bindings/server.c
index 9d7385f..0e4a9b1 100644
--- a/_dbus_bindings/server.c
+++ b/_dbus_bindings/server.c
@@ -107,7 +107,7 @@ DBusPyServer_set_auth_mechanisms(Server *self,
             am = PySequence_Fast_GET_ITEM(auth_mechanisms, i);
             /* this supports either str or unicode, raising TypeError
              * on failure */
-            list[i] = PyString_AsString(am);
+            list[i] = PyBytes_AsString(am);
 
             if (!list[i]) {
                 Py_CLEAR(fast_seq);
@@ -466,7 +466,7 @@ Server_get_address(Server *self, PyObject *args UNUSED)
     address = dbus_server_get_address(self->server);
     Py_END_ALLOW_THREADS
 
-    return PyString_FromString(address);
+    return PyBytes_FromString(address);
 }
 
 PyDoc_STRVAR(Server_get_id__doc__,
@@ -483,7 +483,7 @@ Server_get_id(Server *self, PyObject *args UNUSED)
     id = dbus_server_get_id(self->server);
     Py_END_ALLOW_THREADS
 
-    return PyString_FromString(id);
+    return PyBytes_FromString(id);
 }
 
 PyDoc_STRVAR(Server_get_is_connected__doc__,
diff --git a/_dbus_bindings/signature.c b/_dbus_bindings/signature.c
index cbfc167..c4dd82e 100644
--- a/_dbus_bindings/signature.c
+++ b/_dbus_bindings/signature.c
@@ -145,10 +145,10 @@ Signature_tp_iter (PyObject *self)
     SignatureIter *iter = PyObject_New(SignatureIter, &SignatureIterType);
     if (!iter) return NULL;
 
-    if (PyString_AS_STRING (self)[0]) {
+    if (PyBytes_AS_STRING (self)[0]) {
         Py_INCREF(self);
         iter->string = self;
-        dbus_signature_iter_init(&(iter->iter), PyString_AS_STRING(self));
+        dbus_signature_iter_init(&(iter->iter), PyBytes_AS_STRING(self));
     }
     else {
         /* this is a null string, make a null iterator */
diff --git a/_dbus_bindings/types-internal.h b/_dbus_bindings/types-internal.h
index a5c8147..d24c1c0 100644
--- a/_dbus_bindings/types-internal.h
+++ b/_dbus_bindings/types-internal.h
@@ -26,6 +26,13 @@
 #include <Python.h>
 #include <stdint.h>
 
+/* In Python2 >= 2.6 this aliases PyString to PyBytes.  There is no PyString
+ * in Python 3, so this allows the C extension to be compilable in both Python
+ * versions.  Unfortunately though, the aliases header missed one.
+ */
+#include <bytesobject.h>
+#define PyBytes_InternFromString PyString_InternFromString
+
 #include "dbus_bindings-internal.h"
 
 #ifndef DBUS_BINDINGS_TYPES_INTERNAL_H