diff --git a/Modules/_bytesio.c b/Modules/_bytesio.c
index 88511c6..8c5bb82 100644
--- a/Modules/_bytesio.c
+++ b/Modules/_bytesio.c
@@ -175,7 +175,7 @@
 bytesio_getvalue(BytesIOObject *self)
 {
     CHECK_CLOSED(self);
-    return PyBytes_FromStringAndSize(self->buf, self->string_size);
+    return PyString_FromStringAndSize(self->buf, self->string_size);
 }
 
 PyDoc_STRVAR(isatty_doc,
@@ -244,7 +244,7 @@
     output = self->buf + self->pos;
     self->pos += size;
 
-    return PyBytes_FromStringAndSize(output, size);
+    return PyString_FromStringAndSize(output, size);
 }
 
 
@@ -307,7 +307,7 @@
         self->pos -= size;
     }
 
-    return PyBytes_FromStringAndSize(output, n);
+    return PyString_FromStringAndSize(output, n);
 }
 
 PyDoc_STRVAR(readlines_doc,
@@ -349,7 +349,7 @@
         return NULL;
 
     while ((n = get_line(self, &output)) != 0) {
-        line = PyBytes_FromStringAndSize(output, n);
+        line = PyString_FromStringAndSize(output, n);
         if (!line)
             goto on_error;
         if (PyList_Append(result, line) == -1) {
@@ -455,7 +455,7 @@
     if (!next || n == 0)
         return NULL;
 
-    return PyBytes_FromStringAndSize(next, n);
+    return PyString_FromStringAndSize(next, n);
 }
 
 PyDoc_STRVAR(seek_doc,
diff --git a/Modules/_codecsmodule.c b/Modules/_codecsmodule.c
index e374766..d4eb0d5 100644
--- a/Modules/_codecsmodule.c
+++ b/Modules/_codecsmodule.c
@@ -168,7 +168,7 @@
     if (!PyArg_ParseTuple(args, "s#|z:escape_decode",
 			  &data, &size, &errors))
 	return NULL;
-    return codec_tuple(PyBytes_DecodeEscape(data, size, errors, 0, NULL),
+    return codec_tuple(PyString_DecodeEscape(data, size, errors, 0, NULL),
 		       size);
 }
 
@@ -182,21 +182,21 @@
 	Py_ssize_t len;
 
 	if (!PyArg_ParseTuple(args, "O!|z:escape_encode",
-			      &PyBytes_Type, &str, &errors))
+			      &PyString_Type, &str, &errors))
 		return NULL;
 
-	str = PyBytes_Repr(str, 0);
+	str = PyString_Repr(str, 0);
 	if (!str)
 		return NULL;
 
 	/* The string will be quoted. Unquote, similar to unicode-escape. */
-	buf = PyBytes_AS_STRING (str);
-	len = PyBytes_GET_SIZE (str);
+	buf = PyString_AS_STRING (str);
+	len = PyString_GET_SIZE (str);
 	memmove(buf, buf+1, len-2);
-	if (_PyBytes_Resize(&str, len-2) < 0)
+	if (_PyString_Resize(&str, len-2) < 0)
 		return NULL;
 	
-	return codec_tuple(str, PyBytes_Size(str));
+	return codec_tuple(str, PyString_Size(str));
 }
 
 #ifdef Py_USING_UNICODE
@@ -640,7 +640,7 @@
 			  &data, &size, &errors))
 	return NULL;
 
-    return codec_tuple(PyBytes_FromStringAndSize(data, size),
+    return codec_tuple(PyString_FromStringAndSize(data, size),
 		       size);
 }
 
@@ -656,7 +656,7 @@
 			  &data, &size, &errors))
 	return NULL;
 
-    return codec_tuple(PyBytes_FromStringAndSize(data, size),
+    return codec_tuple(PyString_FromStringAndSize(data, size),
 		       size);
 }
 
@@ -676,13 +676,13 @@
     if (PyUnicode_Check(obj)) {
 	data = PyUnicode_AS_DATA(obj);
 	size = PyUnicode_GET_DATA_SIZE(obj);
-	return codec_tuple(PyBytes_FromStringAndSize(data, size),
+	return codec_tuple(PyString_FromStringAndSize(data, size),
 			   size);
     }
     else {
 	if (PyObject_AsReadBuffer(obj, (const void **)&data, &size))
 	    return NULL;
-	return codec_tuple(PyBytes_FromStringAndSize(data, size),
+	return codec_tuple(PyString_FromStringAndSize(data, size),
 			   size);
     }
 }
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index f7d8d77..67700de 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -668,7 +668,7 @@
 	if (i != 0) {
 		if (i < 0)
 			return NULL;
-		return PyBytes_FromString("[...]");
+		return PyString_FromString("[...]");
 	}
 
 	aslist = PySequence_List(deque);
@@ -677,16 +677,16 @@
 		return NULL;
 	}
 	if (((dequeobject *)deque)->maxlen != -1)
-		fmt = PyBytes_FromFormat("deque(%%r, maxlen=%i)", 
+		fmt = PyString_FromFormat("deque(%%r, maxlen=%i)", 
 					((dequeobject *)deque)->maxlen);
 	else
-		fmt = PyBytes_FromString("deque(%r)");  
+		fmt = PyString_FromString("deque(%r)");  
 	if (fmt == NULL) {
 		Py_DECREF(aslist);
 		Py_ReprLeave(deque);
 		return NULL;
 	}
-	result = PyBytes_Format(fmt, aslist);
+	result = PyString_Format(fmt, aslist);
 	Py_DECREF(fmt);
 	Py_DECREF(aslist);
 	Py_ReprLeave(deque);
@@ -1298,14 +1298,14 @@
 	if (baserepr == NULL)
 		return NULL;
 	if (dd->default_factory == NULL)
-		defrepr = PyBytes_FromString("None");
+		defrepr = PyString_FromString("None");
 	else
 	{
 		int status = Py_ReprEnter(dd->default_factory);
 		if (status != 0) {
 			if (status < 0)
 				return NULL;
-			defrepr = PyBytes_FromString("...");
+			defrepr = PyString_FromString("...");
 		}
 		else
 			defrepr = PyObject_Repr(dd->default_factory);
@@ -1315,9 +1315,9 @@
 		Py_DECREF(baserepr);
 		return NULL;
 	}
-	result = PyBytes_FromFormat("defaultdict(%s, %s)",
-				     PyBytes_AS_STRING(defrepr),
-				     PyBytes_AS_STRING(baserepr));
+	result = PyString_FromFormat("defaultdict(%s, %s)",
+				     PyString_AS_STRING(defrepr),
+				     PyString_AS_STRING(baserepr));
 	Py_DECREF(defrepr);
 	Py_DECREF(baserepr);
 	return result;
diff --git a/Modules/_csv.c b/Modules/_csv.c
index ba9057a..c628927 100644
--- a/Modules/_csv.c
+++ b/Modules/_csv.c
@@ -176,7 +176,7 @@
                 return Py_None;
         }
         else
-                return PyBytes_FromStringAndSize((char*)&c, 1);
+                return PyString_FromStringAndSize((char*)&c, 1);
 }
 
 static PyObject *
@@ -235,16 +235,16 @@
 	if (src == NULL)
 		*target = dflt;
 	else {
-		if (src == Py_None || PyBytes_Size(src) == 0)
+		if (src == Py_None || PyString_Size(src) == 0)
 			*target = '\0';
-		else if (!PyBytes_Check(src) || PyBytes_Size(src) != 1) {
+		else if (!PyString_Check(src) || PyString_Size(src) != 1) {
 			PyErr_Format(PyExc_TypeError, 
 				     "\"%s\" must be an 1-character string", 
 				     name);
 			return -1;
 		}
 		else {
-			char *s = PyBytes_AsString(src);
+			char *s = PyString_AsString(src);
 			if (s == NULL)
 				return -1;
 			*target = s[0];
@@ -257,7 +257,7 @@
 _set_str(const char *name, PyObject **target, PyObject *src, const char *dflt)
 {
 	if (src == NULL)
-		*target = PyBytes_FromString(dflt);
+		*target = PyString_FromString(dflt);
 	else {
 		if (src == Py_None)
 			*target = NULL;
@@ -528,7 +528,7 @@
 {
 	PyObject *field;
 
-	field = PyBytes_FromStringAndSize(self->field, self->field_len);
+	field = PyString_FromStringAndSize(self->field, self->field_len);
 	if (field == NULL)
 		return -1;
 	self->field_len = 0;
@@ -787,8 +787,8 @@
                 }
 		++self->line_num;
 
-                line = PyBytes_AsString(lineobj);
-		linelen = PyBytes_Size(lineobj);
+                line = PyString_AsString(lineobj);
+		linelen = PyString_Size(lineobj);
 
                 if (line == NULL || linelen < 0) {
                         Py_DECREF(lineobj);
@@ -976,7 +976,7 @@
 		rec_len++;\
 	} while(0)
 
-	lineterm = PyBytes_AsString(dialect->lineterminator);
+	lineterm = PyString_AsString(dialect->lineterminator);
 	if (lineterm == NULL)
 		return -1;
 
@@ -1101,7 +1101,7 @@
 	int terminator_len;
 	char *terminator;
 
-	terminator_len = PyBytes_Size(self->dialect->lineterminator);
+	terminator_len = PyString_Size(self->dialect->lineterminator);
 	if (terminator_len == -1)
 		return 0;
 
@@ -1109,7 +1109,7 @@
 	if (!join_check_rec_size(self, self->rec_len + terminator_len))
 		return 0;
 
-	terminator = PyBytes_AsString(self->dialect->lineterminator); 
+	terminator = PyString_AsString(self->dialect->lineterminator); 
 	if (terminator == NULL)
 		return 0;
 	memmove(self->rec + self->rec_len, terminator, terminator_len);
@@ -1161,9 +1161,9 @@
 			break;
 		}
 
-		if (PyBytes_Check(field)) {
+		if (PyString_Check(field)) {
 			append_ok = join_append(self,
-						PyBytes_AS_STRING(field),
+						PyString_AS_STRING(field),
                                                 &quoted, len == 1);
 			Py_DECREF(field);
 		}
@@ -1179,7 +1179,7 @@
 			if (str == NULL)
 				return NULL;
 
-			append_ok = join_append(self, PyBytes_AS_STRING(str), 
+			append_ok = join_append(self, PyString_AS_STRING(str), 
                                                 &quoted, len == 1);
 			Py_DECREF(str);
 		}
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 18851fd..73542c7 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -714,8 +714,8 @@
 	if (-1 == PyType_Type.tp_setattro(self, key, value))
 		return -1;
 	
-	if (value && PyBytes_Check(key) &&
-	    0 == strcmp(PyBytes_AS_STRING(key), "_fields_"))
+	if (value && PyString_Check(key) &&
+	    0 == strcmp(PyString_AS_STRING(key), "_fields_"))
 		return StructUnionType_update_stgdict(self, value, 1);
 	return 0;
 }
@@ -728,8 +728,8 @@
 	if (-1 == PyObject_GenericSetAttr(self, key, value))
 		return -1;
 	
-	if (PyBytes_Check(key) &&
-	    0 == strcmp(PyBytes_AS_STRING(key), "_fields_"))
+	if (PyString_Check(key) &&
+	    0 == strcmp(PyString_AS_STRING(key), "_fields_"))
 		return StructUnionType_update_stgdict(self, value, 0);
 	return 0;
 }
@@ -1065,7 +1065,7 @@
 		size = Py_TYPE(value)->tp_as_buffer->bf_getreadbuffer(value, 0, (void *)&ptr);
 		if (size < 0)
 			return -1;
-	} else if (-1 == PyBytes_AsStringAndSize(value, &ptr, &size)) {
+	} else if (-1 == PyString_AsStringAndSize(value, &ptr, &size)) {
 		return -1;
 	}
 	if (size > self->b_size) {
@@ -1082,7 +1082,7 @@
 static PyObject *
 CharArray_get_raw(CDataObject *self)
 {
-	return PyBytes_FromStringAndSize(self->b_ptr, self->b_size);
+	return PyString_FromStringAndSize(self->b_ptr, self->b_size);
 }
 
 static PyObject *
@@ -1093,7 +1093,7 @@
 	for (i = 0; i < self->b_size; ++i)
 		if (*ptr++ == '\0')
 			break;
-	return PyBytes_FromStringAndSize(self->b_ptr, i);
+	return PyString_FromStringAndSize(self->b_ptr, i);
 }
 
 static int
@@ -1114,14 +1114,14 @@
 						  conversion_mode_errors);
 		if (!value)
 			return -1;
-	} else if (!PyBytes_Check(value)) {
+	} else if (!PyString_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "string expected instead of %s instance",
 			     Py_TYPE(value)->tp_name);
 		return -1;
 	} else
 		Py_INCREF(value);
-	size = PyBytes_GET_SIZE(value);
+	size = PyString_GET_SIZE(value);
 	if (size > self->b_size) {
 		PyErr_SetString(PyExc_ValueError,
 				"string too long");
@@ -1129,7 +1129,7 @@
 		return -1;
 	}
 
-	ptr = PyBytes_AS_STRING(value);
+	ptr = PyString_AS_STRING(value);
 	memcpy(self->b_ptr, ptr, size);
 	if (size < self->b_size)
 		self->b_ptr[size] = '\0';
@@ -1168,7 +1168,7 @@
 				"can't delete attribute");
 		return -1;
 	}
-	if (PyBytes_Check(value)) {
+	if (PyString_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1465,7 +1465,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	if (PyUnicode_Check(value) || PyBytes_Check(value)) {
+	if (PyUnicode_Check(value) || PyString_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("Z");
 
@@ -1529,7 +1529,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	if (PyBytes_Check(value) || PyUnicode_Check(value)) {
+	if (PyString_Check(value) || PyUnicode_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("z");
 
@@ -1615,7 +1615,7 @@
 		return (PyObject *)parg;
 	}
 /* string */
-	if (PyBytes_Check(value)) {
+	if (PyString_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("z");
 
@@ -1686,10 +1686,10 @@
 	}
 /* c_char_p, c_wchar_p */
 	stgd = PyObject_stgdict(value);
-	if (stgd && CDataObject_Check(value) && stgd->proto && PyBytes_Check(stgd->proto)) {
+	if (stgd && CDataObject_Check(value) && stgd->proto && PyString_Check(stgd->proto)) {
 		PyCArgObject *parg;
 
-		switch (PyBytes_AS_STRING(stgd->proto)[0]) {
+		switch (PyString_AS_STRING(stgd->proto)[0]) {
 		case 'z': /* c_char_p */
 		case 'Z': /* c_wchar_p */
 			parg = new_CArgObject();
@@ -1746,13 +1746,13 @@
 
 	if (suffix == NULL)
 #ifdef WORDS_BIGENDIAN
-		suffix = PyBytes_InternFromString("_le");
+		suffix = PyString_InternFromString("_le");
 #else
-		suffix = PyBytes_InternFromString("_be");
+		suffix = PyString_InternFromString("_be");
 #endif
 
 	Py_INCREF(name);
-	PyBytes_Concat(&name, suffix);
+	PyString_Concat(&name, suffix);
 	if (name == NULL)
 		return NULL;
 
@@ -1807,7 +1807,7 @@
 	
 	dict = PyObject_stgdict((PyObject *)self);
 	assert(dict); /* Cannot be NULL for CDataObject instances */
-	fmt = PyBytes_AsString(dict->proto);
+	fmt = PyString_AsString(dict->proto);
 	assert(fmt);
 
 	fd = getentry(fmt);
@@ -1872,12 +1872,12 @@
 			     SIMPLE_TYPE_CHARS);
 		goto error;
 	}
-	fmt = getentry(PyBytes_AS_STRING(proto));
+	fmt = getentry(PyString_AS_STRING(proto));
 	if (fmt == NULL) {
 		Py_DECREF(result);
 		PyErr_Format(PyExc_ValueError,
 			     "_type_ '%s' not supported",
-			     PyBytes_AS_STRING(proto));
+			     PyString_AS_STRING(proto));
 		return NULL;
 	}
 
@@ -1927,7 +1927,7 @@
 	   Overrides the SimpleType_from_param generic method.
 	 */
 	if (result->tp_base == &Simple_Type) {
-		switch (PyBytes_AS_STRING(proto)[0]) {
+		switch (PyString_AS_STRING(proto)[0]) {
 		case 'z': /* c_char_p */
 			ml = &c_char_p_method;
 			stgdict->flags |= TYPEFLAG_ISPOINTER;
@@ -2042,7 +2042,7 @@
 	assert(dict);
 
 	/* I think we can rely on this being a one-character string */
-	fmt = PyBytes_AsString(dict->proto);
+	fmt = PyString_AsString(dict->proto);
 	assert(fmt);
 	
 	fd = getentry(fmt);
@@ -2399,7 +2399,7 @@
 #endif
 		target = target->b_base;
 	}
-	return PyBytes_FromStringAndSize(string, cp-string);
+	return PyString_FromStringAndSize(string, cp-string);
 }
 
 /*
@@ -2571,7 +2571,7 @@
 			     _unpickle,
 			     Py_TYPE(_self),
 			     PyObject_GetAttrString(_self, "__dict__"),
-			     PyBytes_FromStringAndSize(self->b_ptr, self->b_size));
+			     PyString_FromStringAndSize(self->b_ptr, self->b_size));
 }
 
 static PyObject *
@@ -3120,9 +3120,9 @@
 	dict = PyType_stgdict(arg);
 	if (dict
 	    /* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */
-	    && PyBytes_Check(dict->proto)
+	    && PyString_Check(dict->proto)
 /* We only allow c_void_p, c_char_p and c_wchar_p as a simple output parameter type */
-	    && (strchr("PzZ", PyBytes_AS_STRING(dict->proto)[0]))) {
+	    && (strchr("PzZ", PyString_AS_STRING(dict->proto)[0]))) {
 		return 1;
 	}
 
@@ -3207,8 +3207,8 @@
 		return 1;
 	}
 #endif
-	if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
-		*pname = PyBytes_AsString(obj);
+	if (PyString_Check(obj) || PyUnicode_Check(obj)) {
+		*pname = PyString_AsString(obj);
 		return *pname ? 1 : 0;
 	}
 	PyErr_SetString(PyExc_TypeError,
@@ -3558,7 +3558,7 @@
 		/* We HAVE already checked that the tuple can be parsed with "i|zO", so... */
 		Py_ssize_t tsize = PyTuple_GET_SIZE(item);
 		flag = PyInt_AS_LONG(PyTuple_GET_ITEM(item, 0));
-		name = tsize > 1 ? PyBytes_AS_STRING(PyTuple_GET_ITEM(item, 1)) : NULL;
+		name = tsize > 1 ? PyString_AS_STRING(PyTuple_GET_ITEM(item, 1)) : NULL;
 		defval = tsize > 2 ? PyTuple_GET_ITEM(item, 2) : NULL;
 
 		switch (flag & (PARAMFLAG_FIN | PARAMFLAG_FOUT | PARAMFLAG_FLCID)) {
@@ -3612,7 +3612,7 @@
 					     "NULL stgdict unexpected");
 				goto error;
 			}
-			if (PyBytes_Check(dict->proto)) {
+			if (PyString_Check(dict->proto)) {
 				PyErr_Format(
 					PyExc_TypeError,
 					"%s 'out' parameter must be passed as default value",
@@ -3910,12 +3910,12 @@
 {
 #ifdef MS_WIN32
 	if (self->index)
-		return PyBytes_FromFormat("<COM method offset %d: %s at %p>",
+		return PyString_FromFormat("<COM method offset %d: %s at %p>",
 					   self->index - 0x1000,
 					   Py_TYPE(self)->tp_name,
 					   self);
 #endif
-	return PyBytes_FromFormat("<%s object at %p>",
+	return PyString_FromFormat("<%s object at %p>",
 				   Py_TYPE(self)->tp_name,
 				   self);
 }
@@ -4044,7 +4044,7 @@
 			}
 
 			if (kwds && PyDict_GetItem(kwds, name)) {
-				char *field = PyBytes_AsString(name);
+				char *field = PyString_AsString(name);
 				if (field == NULL) {
 					PyErr_Clear();
 					field = "???";
@@ -4246,7 +4246,7 @@
 			     type, so this cannot be NULL */
 	if (itemdict->getfunc == getentry("c")->getfunc) {
 		char *ptr = (char *)self->b_ptr;
-		return PyBytes_FromStringAndSize(ptr + ilow, len);
+		return PyString_FromStringAndSize(ptr + ilow, len);
 #ifdef CTYPES_UNICODE
 	} else if (itemdict->getfunc == getentry("u")->getfunc) {
 		wchar_t *ptr = (wchar_t *)self->b_ptr;
@@ -4303,9 +4303,9 @@
 			char *dest;
 
 			if (slicelen <= 0)
-				return PyBytes_FromString("");
+				return PyString_FromString("");
 			if (step == 1) {
-				return PyBytes_FromStringAndSize(ptr + start,
+				return PyString_FromStringAndSize(ptr + start,
 								  slicelen);
 			}
 			dest = (char *)PyMem_Malloc(slicelen);
@@ -4318,7 +4318,7 @@
 				dest[i] = ptr[cur];
 			}
 
-			np = PyBytes_FromStringAndSize(dest, slicelen);
+			np = PyString_FromStringAndSize(dest, slicelen);
 			PyMem_Free(dest);
 			return np;
 		}
@@ -4728,12 +4728,12 @@
 	static PyObject *format;
 
 	if (Py_TYPE(self)->tp_base != &Simple_Type) {
-		return PyBytes_FromFormat("<%s object at %p>",
+		return PyString_FromFormat("<%s object at %p>",
 					   Py_TYPE(self)->tp_name, self);
 	}
 
 	if (format == NULL) {
-		format = PyBytes_InternFromString("%s(%r)");
+		format = PyString_InternFromString("%s(%r)");
 		if (format == NULL)
 			return NULL;
 	}
@@ -4742,7 +4742,7 @@
 	if (val == NULL)
 		return NULL;
 
-	name = PyBytes_FromString(Py_TYPE(self)->tp_name);
+	name = PyString_FromString(Py_TYPE(self)->tp_name);
 	if (name == NULL) {
 		Py_DECREF(val);
 		return NULL;
@@ -4754,7 +4754,7 @@
 	if (args == NULL)
 		return NULL;
 
-	result = PyBytes_Format(format, args);
+	result = PyString_Format(format, args);
 	Py_DECREF(args);
 	return result;
 }
@@ -4988,7 +4988,7 @@
 	assert(itemdict);
 	if (itemdict->getfunc == getentry("c")->getfunc) {
 		char *ptr = *(char **)self->b_ptr;
-		return PyBytes_FromStringAndSize(ptr + ilow, len);
+		return PyString_FromStringAndSize(ptr + ilow, len);
 #ifdef CTYPES_UNICODE
 	} else if (itemdict->getfunc == getentry("u")->getfunc) {
 		wchar_t *ptr = *(wchar_t **)self->b_ptr;
@@ -5085,9 +5085,9 @@
 			char *dest;
 			
 			if (len <= 0)
-                        	return PyBytes_FromString("");
+                        	return PyString_FromString("");
 			if (step == 1) {
-				return PyBytes_FromStringAndSize(ptr + start,
+				return PyString_FromStringAndSize(ptr + start,
 								  len);
 			}
 			dest = (char *)PyMem_Malloc(len);
@@ -5096,7 +5096,7 @@
 			for (cur = start, i = 0; i < len; cur += step, i++) {
 				dest[i] = ptr[cur];
 			}
-			np = PyBytes_FromStringAndSize(dest, len);
+			np = PyString_FromStringAndSize(dest, len);
 			PyMem_Free(dest);
 			return np;
 		}
@@ -5276,7 +5276,7 @@
 		++methods;
 	}
 
-	s = PyBytes_FromString(comerror_doc);
+	s = PyString_FromString(comerror_doc);
 	if (s == NULL)
 		goto error;
 	status = PyDict_SetItemString(dict, "__doc__", s);
@@ -5302,8 +5302,8 @@
 string_at(const char *ptr, int size)
 {
 	if (size == -1)
-		return PyBytes_FromString(ptr);
-	return PyBytes_FromStringAndSize(ptr, size);
+		return PyString_FromString(ptr);
+	return PyString_FromStringAndSize(ptr, size);
 }
 
 static int
@@ -5317,8 +5317,8 @@
 		return 1;
 	dict = PyType_stgdict(arg);
 	if (dict) {
-		if (PyBytes_Check(dict->proto)
-		    && (strchr("sPzUZXO", PyBytes_AS_STRING(dict->proto)[0]))) {
+		if (PyString_Check(dict->proto)
+		    && (strchr("sPzUZXO", PyString_AS_STRING(dict->proto)[0]))) {
 			/* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */
 			return 1;
 		}
diff --git a/Modules/_ctypes/callbacks.c b/Modules/_ctypes/callbacks.c
index aa02154..0f8c8fa 100644
--- a/Modules/_ctypes/callbacks.c
+++ b/Modules/_ctypes/callbacks.c
@@ -107,15 +107,15 @@
 	PyCodeObject *py_code = 0;
 	PyFrameObject *py_frame = 0;
     
-	py_srcfile = PyBytes_FromString(filename);
+	py_srcfile = PyString_FromString(filename);
 	if (!py_srcfile) goto bad;
-	py_funcname = PyBytes_FromString(funcname);
+	py_funcname = PyString_FromString(funcname);
 	if (!py_funcname) goto bad;
 	py_globals = PyDict_New();
 	if (!py_globals) goto bad;
 	empty_tuple = PyTuple_New(0);
 	if (!empty_tuple) goto bad;
-	empty_string = PyBytes_FromString("");
+	empty_string = PyString_FromString("");
 	if (!empty_string) goto bad;
 	py_code = PyCode_New(
 		0,            /*int argcount,*/
@@ -498,7 +498,7 @@
 	static PyObject *context;
 
 	if (context == NULL)
-		context = PyBytes_InternFromString("_ctypes.DllGetClassObject");
+		context = PyString_InternFromString("_ctypes.DllGetClassObject");
 
 	mod = PyImport_ImportModuleNoBlock("ctypes");
 	if (!mod) {
@@ -577,7 +577,7 @@
 	static PyObject *context;
 
 	if (context == NULL)
-		context = PyBytes_InternFromString("_ctypes.DllCanUnloadNow");
+		context = PyString_InternFromString("_ctypes.DllCanUnloadNow");
 
 	mod = PyImport_ImportModuleNoBlock("ctypes");
 	if (!mod) {
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index 12b0d7a..825a2c7 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -498,7 +498,7 @@
 			self->tag, self);
 		break;
 	}
-	return PyBytes_FromString(buffer);
+	return PyString_FromString(buffer);
 }
 
 static PyMemberDef PyCArgType_members[] = {
@@ -646,9 +646,9 @@
 		return 0;
 	}
 
-	if (PyBytes_Check(obj)) {
+	if (PyString_Check(obj)) {
 		pa->ffi_type = &ffi_type_pointer;
-		pa->value.p = PyBytes_AS_STRING(obj);
+		pa->value.p = PyString_AS_STRING(obj);
 		Py_INCREF(obj);
 		pa->keep = obj;
 		return 0;
@@ -937,7 +937,7 @@
 	PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;
 
 	va_start(vargs, fmt);
-	s = PyBytes_FromFormatV(fmt, vargs);
+	s = PyString_FromFormatV(fmt, vargs);
 	va_end(vargs);
 	if (!s)
 		return;
@@ -946,18 +946,18 @@
 	PyErr_NormalizeException(&tp, &v, &tb);
 	cls_str = PyObject_Str(tp);
 	if (cls_str) {
-		PyBytes_ConcatAndDel(&s, cls_str);
-		PyBytes_ConcatAndDel(&s, PyBytes_FromString(": "));
+		PyString_ConcatAndDel(&s, cls_str);
+		PyString_ConcatAndDel(&s, PyString_FromString(": "));
 		if (s == NULL)
 			goto error;
 	} else
 		PyErr_Clear();
 	msg_str = PyObject_Str(v);
 	if (msg_str)
-		PyBytes_ConcatAndDel(&s, msg_str);
+		PyString_ConcatAndDel(&s, msg_str);
 	else {
 		PyErr_Clear();
-		PyBytes_ConcatAndDel(&s, PyBytes_FromString("???"));
+		PyString_ConcatAndDel(&s, PyString_FromString("???"));
 		if (s == NULL)
 			goto error;
 	}
@@ -1261,7 +1261,7 @@
 	if (!PyArg_ParseTuple(args, "O|O:LoadLibrary", &nameobj, &ignored))
 		return NULL;
 #ifdef _UNICODE
-	name = alloca((PyBytes_Size(nameobj) + 1) * sizeof(WCHAR));
+	name = alloca((PyString_Size(nameobj) + 1) * sizeof(WCHAR));
 	if (!name) {
 		PyErr_NoMemory();
 		return NULL;
@@ -1269,14 +1269,14 @@
 
 	{
 		int r;
-		char *aname = PyBytes_AsString(nameobj);
+		char *aname = PyString_AsString(nameobj);
 		if(!aname)
 			return NULL;
-		r = MultiByteToWideChar(CP_ACP, 0, aname, -1, name, PyBytes_Size(nameobj) + 1);
+		r = MultiByteToWideChar(CP_ACP, 0, aname, -1, name, PyString_Size(nameobj) + 1);
 		name[r] = 0;
 	}
 #else
-	name = PyBytes_AsString(nameobj);
+	name = PyString_AsString(nameobj);
 	if(!name)
 		return NULL;
 #endif
@@ -1769,9 +1769,9 @@
 		Py_INCREF(result);
 		return result;
 	}
-	if (PyBytes_CheckExact(cls)) {
-		buf = alloca(strlen(PyBytes_AS_STRING(cls)) + 3 + 1);
-		sprintf(buf, "LP_%s", PyBytes_AS_STRING(cls));
+	if (PyString_CheckExact(cls)) {
+		buf = alloca(strlen(PyString_AS_STRING(cls)) + 3 + 1);
+		sprintf(buf, "LP_%s", PyString_AS_STRING(cls));
 		result = PyObject_CallFunction((PyObject *)Py_TYPE(&Pointer_Type),
 					       "s(O){}",
 					       buf,
diff --git a/Modules/_ctypes/cfield.c b/Modules/_ctypes/cfield.c
index 5105493..ba837ec 100644
--- a/Modules/_ctypes/cfield.c
+++ b/Modules/_ctypes/cfield.c
@@ -272,7 +272,7 @@
 	name = ((PyTypeObject *)self->proto)->tp_name;
 
 	if (bits)
-		result = PyBytes_FromFormat(
+		result = PyString_FromFormat(
 #if (PY_VERSION_HEX < 0x02050000)
 			"<Field type=%s, ofs=%d:%d, bits=%d>",
 #else
@@ -280,7 +280,7 @@
 #endif
 			name, self->offset, size, bits);
 	else
-		result = PyBytes_FromFormat(
+		result = PyString_FromFormat(
 #if (PY_VERSION_HEX < 0x02050000)
 			"<Field type=%s, ofs=%d, size=%d>",
 #else
@@ -1164,12 +1164,12 @@
 static PyObject *
 c_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
-	if (!PyBytes_Check(value) || (1 != PyBytes_Size(value))) {
+	if (!PyString_Check(value) || (1 != PyString_Size(value))) {
 		PyErr_Format(PyExc_TypeError,
 			     "one character string expected");
 		return NULL;
 	}
-	*(char *)ptr = PyBytes_AS_STRING(value)[0];
+	*(char *)ptr = PyString_AS_STRING(value)[0];
 	_RET(value);
 }
 
@@ -1177,7 +1177,7 @@
 static PyObject *
 c_get(void *ptr, Py_ssize_t size)
 {
-	return PyBytes_FromStringAndSize((char *)ptr, 1);
+	return PyString_FromStringAndSize((char *)ptr, 1);
 }
 
 #ifdef CTYPES_UNICODE
@@ -1187,7 +1187,7 @@
 {
 	Py_ssize_t len;
 
-	if (PyBytes_Check(value)) {
+	if (PyString_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1262,7 +1262,7 @@
 	/* It's easier to calculate in characters than in bytes */
 	length /= sizeof(wchar_t);
 
-	if (PyBytes_Check(value)) {
+	if (PyString_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1301,21 +1301,21 @@
 	PyObject *result;
 	size_t slen;
 
-	result = PyBytes_FromString((char *)ptr);
+	result = PyString_FromString((char *)ptr);
 	if (!result)
 		return NULL;
 	/* chop off at the first NUL character, if any.
 	 * On error, result will be deallocated and set to NULL.
 	 */
-	slen = strlen(PyBytes_AS_STRING(result));
+	slen = strlen(PyString_AS_STRING(result));
 	size = min(size, (Py_ssize_t)slen);
 	if (result->ob_refcnt == 1) {
 		/* shorten the result */
-		_PyBytes_Resize(&result, size);
+		_PyString_Resize(&result, size);
 		return result;
 	} else
 		/* cannot shorten the result */
-		return PyBytes_FromStringAndSize(ptr, size);
+		return PyString_FromStringAndSize(ptr, size);
 }
 
 static PyObject *
@@ -1324,7 +1324,7 @@
 	char *data;
 	Py_ssize_t size;
 
-	data = PyBytes_AsString(value);
+	data = PyString_AsString(value);
 	if (!data)
 		return NULL;
 	size = strlen(data);
@@ -1356,8 +1356,8 @@
 		Py_INCREF(value);
 		return value;
 	}
-	if (PyBytes_Check(value)) {
-		*(char **)ptr = PyBytes_AS_STRING(value);
+	if (PyString_Check(value)) {
+		*(char **)ptr = PyString_AS_STRING(value);
 		Py_INCREF(value);
 		return value;
 	} else if (PyUnicode_Check(value)) {
@@ -1366,7 +1366,7 @@
 							  conversion_mode_errors);
 		if (str == NULL)
 			return NULL;
-		*(char **)ptr = PyBytes_AS_STRING(str);
+		*(char **)ptr = PyString_AS_STRING(str);
 		return str;
 	} else if (PyInt_Check(value) || PyLong_Check(value)) {
 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
@@ -1395,7 +1395,7 @@
 			return NULL;
 		}
 #endif
-		return PyBytes_FromString(*(char **)ptr);
+		return PyString_FromString(*(char **)ptr);
 	} else {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1411,7 +1411,7 @@
 		Py_INCREF(value);
 		return value;
 	}
-	if (PyBytes_Check(value)) {
+	if (PyString_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1502,7 +1502,7 @@
 	/* convert value into a PyUnicodeObject or NULL */
 	if (Py_None == value) {
 		value = NULL;
-	} else if (PyBytes_Check(value)) {
+	} else if (PyString_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
diff --git a/Modules/_curses_panel.c b/Modules/_curses_panel.c
index 6b618ac..6831473 100644
--- a/Modules/_curses_panel.c
+++ b/Modules/_curses_panel.c
@@ -472,7 +472,7 @@
     PyDict_SetItemString(d, "error", PyCursesError);
 
     /* Make the version available */
-    v = PyBytes_FromString(PyCursesVersion);
+    v = PyString_FromString(PyCursesVersion);
     PyDict_SetItemString(d, "version", v);
     PyDict_SetItemString(d, "__version__", v);
     Py_DECREF(v);
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index 964a260..137c580 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -198,9 +198,9 @@
 {
   if (PyInt_Check(obj)) {
     *ch = (chtype) PyInt_AsLong(obj);
-  } else if(PyBytes_Check(obj) 
-	    && (PyBytes_Size(obj) == 1)) {
-    *ch = (chtype) *PyBytes_AsString(obj);
+  } else if(PyString_Check(obj) 
+	    && (PyString_Size(obj) == 1)) {
+    *ch = (chtype) *PyString_AsString(obj);
   } else {
     return 0;
   }
@@ -886,9 +886,9 @@
     return Py_BuildValue("c", rtn);
   else
 #if defined(__NetBSD__)
-    return PyBytes_FromString(unctrl(rtn));
+    return PyString_FromString(unctrl(rtn));
 #else
-    return PyBytes_FromString((char *)keyname(rtn));
+    return PyString_FromString((char *)keyname(rtn));
 #endif
 }
 
@@ -943,7 +943,7 @@
   }
   if (rtn2 == ERR)
     rtn[0] = 0;
-  return PyBytes_FromString(rtn);
+  return PyString_FromString(rtn);
 }
 
 static PyObject *
@@ -1095,7 +1095,7 @@
   }
   if (rtn2 == ERR)
     rtn[0] = 0;
-  return PyBytes_FromString(rtn);
+  return PyString_FromString(rtn);
 }
 
 static PyObject *
@@ -1757,7 +1757,7 @@
 
   ch = erasechar();
 
-  return PyBytes_FromStringAndSize(&ch, 1);
+  return PyString_FromStringAndSize(&ch, 1);
 }
 
 static PyObject *
@@ -2114,7 +2114,7 @@
   }
   knp = keyname(ch);
 
-  return PyBytes_FromString((knp == NULL) ? "" : (char *)knp);
+  return PyString_FromString((knp == NULL) ? "" : (char *)knp);
 }
 #endif
 
@@ -2125,7 +2125,7 @@
 
   ch = killchar();  
 
-  return PyBytes_FromStringAndSize(&ch, 1);  
+  return PyString_FromStringAndSize(&ch, 1);  
 }  
 
 static PyObject *
@@ -2496,7 +2496,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString( capname );
+	return PyString_FromString( capname );
 }
 
 static PyObject *
@@ -2520,7 +2520,7 @@
   		return NULL;
 	}
 
-	return PyBytes_FromString(result);
+	return PyString_FromString(result);
 }
 
 static PyObject *
@@ -2547,14 +2547,14 @@
 
   if (PyInt_Check(temp))
     ch = (chtype) PyInt_AsLong(temp);
-  else if (PyBytes_Check(temp))
-    ch = (chtype) *PyBytes_AsString(temp);
+  else if (PyString_Check(temp))
+    ch = (chtype) *PyString_AsString(temp);
   else {
     PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
     return NULL;
   }
 
-  return PyBytes_FromString(unctrl(ch));
+  return PyString_FromString(unctrl(ch));
 }
 
 static PyObject *
@@ -2569,8 +2569,8 @@
 
   if (PyInt_Check(temp))
     ch = (int) PyInt_AsLong(temp);
-  else if (PyBytes_Check(temp))
-    ch = (int) *PyBytes_AsString(temp);
+  else if (PyString_Check(temp))
+    ch = (int) *PyString_AsString(temp);
   else {
     PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
     return NULL;
@@ -2753,7 +2753,7 @@
 	PyDict_SetItemString(d, "error", PyCursesError);
 
 	/* Make the version available */
-	v = PyBytes_FromString(PyCursesVersion);
+	v = PyString_FromString(PyCursesVersion);
 	PyDict_SetItemString(d, "version", v);
 	PyDict_SetItemString(d, "__version__", v);
 	Py_DECREF(v);
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index e368b31..684081c 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -103,7 +103,7 @@
 #define PyDict_CheckExact PyDict_Check
 #if (PY_VERSION_HEX < 0x02020000)
 #define PyList_CheckExact PyList_Check
-#define PyBytes_CheckExact PyBytes_Check
+#define PyString_CheckExact PyString_Check
 #if (PY_VERSION_HEX >= 0x01060000)
 #define Py_USING_UNICODE /* always enabled for 2.0 and 2.1 */
 #endif
@@ -173,7 +173,7 @@
     switch (PyList_GET_SIZE(list)) {
     case 0:
         Py_DECREF(list);
-        return PyBytes_FromString("");
+        return PyString_FromString("");
     case 1:
         result = PyList_GET_ITEM(list, 0);
         Py_INCREF(result);
@@ -748,9 +748,9 @@
         return 0;
     }
 #endif
-    if (PyBytes_Check(tag)) {
-        char *p = PyBytes_AS_STRING(tag);
-        for (i = 0; i < PyBytes_GET_SIZE(tag); i++) {
+    if (PyString_Check(tag)) {
+        char *p = PyString_AS_STRING(tag);
+        for (i = 0; i < PyString_GET_SIZE(tag); i++) {
             if (p[i] == '{')
                 check = 0;
             else if (p[i] == '}')
@@ -818,7 +818,7 @@
         if (Element_CheckExact(item) && !PyObject_Compare(item->tag, tag)) {
             PyObject* text = element_get_text(item);
             if (text == Py_None)
-                return PyBytes_FromString("");
+                return PyString_FromString("");
             Py_XINCREF(text);
             return text;
         }
@@ -1154,12 +1154,12 @@
     PyObject* repr;
     char buffer[100];
     
-    repr = PyBytes_FromString("<Element ");
+    repr = PyString_FromString("<Element ");
 
-    PyBytes_ConcatAndDel(&repr, PyObject_Repr(self->tag));
+    PyString_ConcatAndDel(&repr, PyObject_Repr(self->tag));
 
     sprintf(buffer, " at %p>", self);
-    PyBytes_ConcatAndDel(&repr, PyBytes_FromString(buffer));
+    PyString_ConcatAndDel(&repr, PyString_FromString(buffer));
 
     return repr;
 }
@@ -1617,14 +1617,14 @@
         Py_INCREF(data); self->data = data;
     } else {
         /* more than one item; use a list to collect items */
-        if (PyBytes_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
-            PyBytes_CheckExact(data) && PyBytes_GET_SIZE(data) == 1) {
+        if (PyString_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
+            PyString_CheckExact(data) && PyString_GET_SIZE(data) == 1) {
             /* expat often generates single character data sections; handle
                the most common case by resizing the existing string... */
-            Py_ssize_t size = PyBytes_GET_SIZE(self->data);
-            if (_PyBytes_Resize(&self->data, size + 1) < 0)
+            Py_ssize_t size = PyString_GET_SIZE(self->data);
+            if (_PyString_Resize(&self->data, size + 1) < 0)
                 return NULL;
-            PyBytes_AS_STRING(self->data)[size] = PyBytes_AS_STRING(data)[0];
+            PyString_AS_STRING(self->data)[size] = PyString_AS_STRING(data)[0];
         } else if (PyList_CheckExact(self->data)) {
             if (PyList_Append(self->data, data) < 0)
                 return NULL;
@@ -1896,7 +1896,7 @@
         return PyUnicode_DecodeUTF8(string, size, "strict");
 #endif
 
-    return PyBytes_FromStringAndSize(string, size);
+    return PyString_FromStringAndSize(string, size);
 }
 
 LOCAL(PyObject*)
@@ -1910,7 +1910,7 @@
     PyObject* value;
 
     /* look the 'raw' name up in the names dictionary */
-    key = PyBytes_FromStringAndSize(string, size);
+    key = PyString_FromStringAndSize(string, size);
     if (!key)
         return NULL;
 
@@ -1932,8 +1932,8 @@
                 break;
         if (i != size) {
             /* convert to universal name */
-            tag = PyBytes_FromStringAndSize(NULL, size+1);
-            p = PyBytes_AS_STRING(tag);
+            tag = PyString_FromStringAndSize(NULL, size+1);
+            p = PyString_AS_STRING(tag);
             p[0] = '{';
             memcpy(p+1, string, size);
             size++;
@@ -1947,7 +1947,7 @@
 #if defined(Py_USING_UNICODE)
         /* inline makestring, to avoid duplicating the source string if
            it's not an utf-8 string */
-        p = PyBytes_AS_STRING(tag);
+        p = PyString_AS_STRING(tag);
         if (checkstring(p, size)) {
             value = PyUnicode_DecodeUTF8(p, size, "strict");
             Py_DECREF(tag);
@@ -2004,7 +2004,7 @@
     } else {
         PyErr_Format(
             PyExc_SyntaxError, "undefined entity &%s;: line %ld, column %ld",
-            PyBytes_AS_STRING(key),
+            PyString_AS_STRING(key),
             EXPAT(GetErrorLineNumber)(self->parser),
             EXPAT(GetErrorColumnNumber)(self->parser)
             );
@@ -2435,13 +2435,13 @@
             return NULL;
         }
 
-        if (!PyBytes_CheckExact(buffer) || PyBytes_GET_SIZE(buffer) == 0) {
+        if (!PyString_CheckExact(buffer) || PyString_GET_SIZE(buffer) == 0) {
             Py_DECREF(buffer);
             break;
         }
 
         res = expat_parse(
-            self, PyBytes_AS_STRING(buffer), PyBytes_GET_SIZE(buffer), 0
+            self, PyString_AS_STRING(buffer), PyString_GET_SIZE(buffer), 0
             );
 
         Py_DECREF(buffer);
@@ -2503,7 +2503,7 @@
 
     if (event_set == Py_None) {
         /* default is "end" only */
-        target->end_event_obj = PyBytes_FromString("end");
+        target->end_event_obj = PyString_FromString("end");
         Py_RETURN_NONE;
     }
 
@@ -2513,9 +2513,9 @@
     for (i = 0; i < PyTuple_GET_SIZE(event_set); i++) {
         PyObject* item = PyTuple_GET_ITEM(event_set, i);
         char* event;
-        if (!PyBytes_Check(item))
+        if (!PyString_Check(item))
             goto error;
-        event = PyBytes_AS_STRING(item);
+        event = PyString_AS_STRING(item);
         if (strcmp(event, "start") == 0) {
             Py_INCREF(item);
             target->start_event_obj = item;
@@ -2587,7 +2587,7 @@
         char buffer[100];
         sprintf(buffer, "Expat %d.%d.%d", XML_MAJOR_VERSION,
                 XML_MINOR_VERSION, XML_MICRO_VERSION);
-        return PyBytes_FromString(buffer);
+        return PyString_FromString(buffer);
     } else {
         PyErr_SetString(PyExc_AttributeError, name);
         return NULL;
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
index aa5b59f..1cb697b 100644
--- a/Modules/_fileio.c
+++ b/Modules/_fileio.c
@@ -392,14 +392,14 @@
 	Py_ssize_t total = 0;
 	int n;
 
-	result = PyBytes_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
+	result = PyString_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
 	if (result == NULL)
 		return NULL;
 
 	while (1) {
 		Py_ssize_t newsize = total + DEFAULT_BUFFER_SIZE;
-		if (PyBytes_GET_SIZE(result) < newsize) {
-			if (_PyBytes_Resize(&result, newsize) < 0) {
+		if (PyString_GET_SIZE(result) < newsize) {
+			if (_PyString_Resize(&result, newsize) < 0) {
 				if (total == 0) {
 					Py_DECREF(result);
 					return NULL;
@@ -411,7 +411,7 @@
 		Py_BEGIN_ALLOW_THREADS
 		errno = 0;
 		n = read(self->fd,
-			 PyBytes_AS_STRING(result) + total,
+			 PyString_AS_STRING(result) + total,
 			 newsize - total);
 		Py_END_ALLOW_THREADS
 		if (n == 0)
@@ -430,8 +430,8 @@
 		total += n;
 	}
 
-	if (PyBytes_GET_SIZE(result) > total) {
-		if (_PyBytes_Resize(&result, total) < 0) {
+	if (PyString_GET_SIZE(result) > total) {
+		if (_PyString_Resize(&result, total) < 0) {
 			/* This should never happen, but just in case */
 			Py_DECREF(result);
 			return NULL;
@@ -460,10 +460,10 @@
 		return fileio_readall(self);
 	}
 
-	bytes = PyBytes_FromStringAndSize(NULL, size);
+	bytes = PyString_FromStringAndSize(NULL, size);
 	if (bytes == NULL)
 		return NULL;
-	ptr = PyBytes_AS_STRING(bytes);
+	ptr = PyString_AS_STRING(bytes);
 
 	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
@@ -478,7 +478,7 @@
 	}
 
 	if (n != size) {
-		if (_PyBytes_Resize(&bytes, n) < 0) {
+		if (_PyString_Resize(&bytes, n) < 0) {
 			Py_DECREF(bytes);
 			return NULL;
 		}
@@ -690,9 +690,9 @@
 fileio_repr(PyFileIOObject *self)
 {
         if (self->fd < 0)
-		return PyBytes_FromFormat("_fileio._FileIO(-1)");
+		return PyString_FromFormat("_fileio._FileIO(-1)");
 
-	return PyBytes_FromFormat("_fileio._FileIO(%d, '%s')",
+	return PyString_FromFormat("_fileio._FileIO(%d, '%s')",
 				   self->fd, mode_string(self));
 }
 
@@ -816,7 +816,7 @@
 static PyObject *
 get_mode(PyFileIOObject *self, void *closure)
 {
-	return PyBytes_FromString(mode_string(self));
+	return PyString_FromString(mode_string(self));
 }
 
 static PyGetSetDef fileio_getsetlist[] = {
diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
index 7bca2da..8e5121f 100644
--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
@@ -103,7 +103,7 @@
     digest_size = EVP_MD_CTX_size(&temp_ctx);
     EVP_DigestFinal(&temp_ctx, digest, NULL);
 
-    retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);
+    retval = PyString_FromStringAndSize((const char *)digest, digest_size);
     EVP_MD_CTX_cleanup(&temp_ctx);
     return retval;
 }
@@ -130,10 +130,10 @@
     /* Create a new string */
     /* NOTE: not thread safe! modifying an already created string object */
     /* (not a problem because we hold the GIL by default) */
-    retval = PyBytes_FromStringAndSize(NULL, digest_size * 2);
+    retval = PyString_FromStringAndSize(NULL, digest_size * 2);
     if (!retval)
 	    return NULL;
-    hex_digest = PyBytes_AsString(retval);
+    hex_digest = PyString_AsString(retval);
     if (!hex_digest) {
 	    Py_DECREF(retval);
 	    return NULL;
@@ -220,8 +220,8 @@
 {
     char buf[100];
     PyOS_snprintf(buf, sizeof(buf), "<%s HASH object @ %p>",
-            PyBytes_AsString(((EVPobject *)self)->name), self);
-    return PyBytes_FromString(buf);
+            PyString_AsString(((EVPobject *)self)->name), self);
+    return PyString_FromString(buf);
 }
 
 #if HASH_OBJ_CONSTRUCTOR
@@ -421,7 +421,7 @@
 
 /* used in the init function to setup a constructor */
 #define INIT_CONSTRUCTOR_CONSTANTS(NAME)  do { \
-    CONST_ ## NAME ## _name_obj = PyBytes_FromString(#NAME); \
+    CONST_ ## NAME ## _name_obj = PyString_FromString(#NAME); \
     if (EVP_get_digestbyname(#NAME)) { \
         CONST_new_ ## NAME ## _ctx_p = &CONST_new_ ## NAME ## _ctx; \
         EVP_DigestInit(CONST_new_ ## NAME ## _ctx_p, EVP_get_digestbyname(#NAME)); \
diff --git a/Modules/_heapqmodule.c b/Modules/_heapqmodule.c
index aa5bbb1..7a64161 100644
--- a/Modules/_heapqmodule.c
+++ b/Modules/_heapqmodule.c
@@ -687,6 +687,6 @@
 	m = Py_InitModule3("_heapq", heapq_methods, module_doc);
 	if (m == NULL)
     		return;
-	PyModule_AddObject(m, "__about__", PyBytes_FromString(__about__));
+	PyModule_AddObject(m, "__about__", PyString_FromString(__about__));
 }
 
diff --git a/Modules/_hotshot.c b/Modules/_hotshot.c
index 7c8bdd9..4c66e2a 100644
--- a/Modules/_hotshot.c
+++ b/Modules/_hotshot.c
@@ -326,7 +326,7 @@
             return ERR_EOF;
         }
     }
-    *pvalue = PyBytes_FromStringAndSize(buf, len);
+    *pvalue = PyString_FromStringAndSize(buf, len);
     free(buf);
     if (*pvalue == NULL) {
         return ERR_EXCEPTION;
@@ -562,7 +562,7 @@
                 self->index - written);
         self->index -= written;
         if (written == 0) {
-            char *s = PyBytes_AsString(self->logfilename);
+            char *s = PyString_AsString(self->logfilename);
             PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
             do_stop(self);
             return -1;
@@ -570,7 +570,7 @@
     }
     if (written > 0) {
         if (fflush(self->logfp)) {
-            char *s = PyBytes_AsString(self->logfilename);
+            char *s = PyString_AsString(self->logfilename);
             PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
             do_stop(self);
             return -1;
@@ -792,7 +792,7 @@
         self->next_fileno++;
         Py_DECREF(obj);
         if (pack_define_file(self, fileno,
-                             PyBytes_AS_STRING(fcode->co_filename)) < 0)
+                             PyString_AS_STRING(fcode->co_filename)) < 0)
             return -1;
     }
     else {
@@ -810,7 +810,7 @@
         PyObject *name = PyDict_GetItem(dict, obj);
         if (name == NULL) {
             if (pack_define_func(self, fileno, fcode->co_firstlineno,
-                                 PyBytes_AS_STRING(fcode->co_name)) < 0) {
+                                 PyString_AS_STRING(fcode->co_name)) < 0) {
                 Py_DECREF(obj);
                 return -1;
             }
@@ -1471,7 +1471,7 @@
     len = PyList_GET_SIZE(temp);
     for (i = 0; i < len; ++i) {
         PyObject *item = PyList_GET_ITEM(temp, i);
-        buffer = PyBytes_AsString(item);
+        buffer = PyString_AsString(item);
         if (buffer == NULL) {
             pack_add_info(self, "sys-path-entry", "<non-string-path-entry>");
             PyErr_Clear();
diff --git a/Modules/_json.c b/Modules/_json.c
index 30cdc0f..ea6d66f 100644
--- a/Modules/_json.c
+++ b/Modules/_json.c
@@ -70,11 +70,11 @@
     input_unicode = PyUnicode_AS_UNICODE(pystr);
     /* One char input can be up to 6 chars output, estimate 4 of these */
     output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
-    rval = PyBytes_FromStringAndSize(NULL, output_size);
+    rval = PyString_FromStringAndSize(NULL, output_size);
     if (rval == NULL) {
         return NULL;
     }
-    output = PyBytes_AS_STRING(rval);
+    output = PyString_AS_STRING(rval);
     chars = 0;
     output[chars++] = '"';
     for (i = 0; i < input_chars; i++) {
@@ -92,14 +92,14 @@
             if (output_size > 2 + (input_chars * MAX_EXPANSION)) {
                 output_size = 2 + (input_chars * MAX_EXPANSION);
             }
-            if (_PyBytes_Resize(&rval, output_size) == -1) {
+            if (_PyString_Resize(&rval, output_size) == -1) {
                 return NULL;
             }
-            output = PyBytes_AS_STRING(rval);
+            output = PyString_AS_STRING(rval);
         }
     }
     output[chars++] = '"';
-    if (_PyBytes_Resize(&rval, chars) == -1) {
+    if (_PyString_Resize(&rval, chars) == -1) {
         return NULL;
     }
     return rval;
@@ -116,15 +116,15 @@
     char *output;
     char *input_str;
 
-    input_chars = PyBytes_GET_SIZE(pystr);
-    input_str = PyBytes_AS_STRING(pystr);
+    input_chars = PyString_GET_SIZE(pystr);
+    input_str = PyString_AS_STRING(pystr);
     /* One char input can be up to 6 chars output, estimate 4 of these */
     output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
-    rval = PyBytes_FromStringAndSize(NULL, output_size);
+    rval = PyString_FromStringAndSize(NULL, output_size);
     if (rval == NULL) {
         return NULL;
     }
-    output = PyBytes_AS_STRING(rval);
+    output = PyString_AS_STRING(rval);
     chars = 0;
     output[chars++] = '"';
     for (i = 0; i < input_chars; i++) {
@@ -154,14 +154,14 @@
             if (output_size > 2 + (input_chars * MIN_EXPANSION)) {
                 output_size = 2 + (input_chars * MIN_EXPANSION);
             }
-            if (_PyBytes_Resize(&rval, output_size) == -1) {
+            if (_PyString_Resize(&rval, output_size) == -1) {
                 return NULL;
             }
-            output = PyBytes_AS_STRING(rval);
+            output = PyString_AS_STRING(rval);
         }
     }
     output[chars++] = '"';
-    if (_PyBytes_Resize(&rval, chars) == -1) {
+    if (_PyString_Resize(&rval, chars) == -1) {
         return NULL;
     }
     return rval;
@@ -215,7 +215,7 @@
         ustr = PyUnicode_FromUnicode(&c, 0);
     }
     if (joinstr == NULL) {
-        joinstr = PyBytes_InternFromString("join");
+        joinstr = PyString_InternFromString("join");
     }
     if (joinstr == NULL || ustr == NULL) {
         return NULL;
@@ -227,10 +227,10 @@
 scanstring_str(PyObject *pystr, Py_ssize_t end, char *encoding, int strict)
 {
     PyObject *rval;
-    Py_ssize_t len = PyBytes_GET_SIZE(pystr);
+    Py_ssize_t len = PyString_GET_SIZE(pystr);
     Py_ssize_t begin = end - 1;
     Py_ssize_t next = begin;
-    char *buf = PyBytes_AS_STRING(pystr);
+    char *buf = PyString_AS_STRING(pystr);
     PyObject *chunks = PyList_New(0);
     if (chunks == NULL) {
         goto bail;
@@ -555,7 +555,7 @@
     if (encoding == NULL) {
         encoding = DEFAULT_ENCODING;
     }
-    if (PyBytes_Check(pystr)) {
+    if (PyString_Check(pystr)) {
         return scanstring_str(pystr, end, encoding, strict);
     }
     else if (PyUnicode_Check(pystr)) {
@@ -576,7 +576,7 @@
 py_encode_basestring_ascii(PyObject* self, PyObject *pystr)
 {
     /* METH_O */
-    if (PyBytes_Check(pystr)) {
+    if (PyString_Check(pystr)) {
         return ascii_escape_str(pystr);
     }
     else if (PyUnicode_Check(pystr)) {
diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c
index ce84b27..02e9e53 100644
--- a/Modules/_localemodule.c
+++ b/Modules/_localemodule.c
@@ -119,7 +119,7 @@
         if (isupper(c))
             ul[n++] = c;
     }
-    ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+    ulo = PyString_FromStringAndSize((const char *)ul, n);
     if (!ulo)
         return;
     if (string)
@@ -134,7 +134,7 @@
         if (islower(c))
             ul[n++] = c;
     }
-    ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+    ulo = PyString_FromStringAndSize((const char *)ul, n);
     if (!ulo)
         return;
     if (string)
@@ -149,7 +149,7 @@
         if (isalpha(c))
             ul[n++] = c;
     }
-    ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+    ulo = PyString_FromStringAndSize((const char *)ul, n);
     if (!ulo)
         return;
     if (string)
@@ -175,7 +175,7 @@
             PyErr_SetString(Error, "unsupported locale setting");
             return NULL;
         }
-        result_object = PyBytes_FromString(result);
+        result_object = PyString_FromString(result);
         if (!result_object)
             return NULL;
         /* record changes to LC_CTYPE */
@@ -190,7 +190,7 @@
             PyErr_SetString(Error, "locale query failed");
             return NULL;
         }
-        result_object = PyBytes_FromString(result);
+        result_object = PyString_FromString(result);
     }
     return result_object;
 }
@@ -216,7 +216,7 @@
        involved herein */
 
 #define RESULT_STRING(s)\
-    x = PyBytes_FromString(l->s);\
+    x = PyString_FromString(l->s);\
     if (!x) goto failed;\
     PyDict_SetItemString(result, #s, x);\
     Py_XDECREF(x)
@@ -284,9 +284,9 @@
     if (!PyArg_UnpackTuple(args, "strcoll", 2, 2, &os1, &os2))
         return NULL;
     /* If both arguments are byte strings, use strcoll.  */
-    if (PyBytes_Check(os1) && PyBytes_Check(os2))
-        return PyInt_FromLong(strcoll(PyBytes_AS_STRING(os1),
-                                      PyBytes_AS_STRING(os2)));
+    if (PyString_Check(os1) && PyString_Check(os2))
+        return PyInt_FromLong(strcoll(PyString_AS_STRING(os1),
+                                      PyString_AS_STRING(os2)));
     /* If neither argument is unicode, it's an error.  */
     if (!PyUnicode_Check(os1) && !PyUnicode_Check(os2)) {
         PyErr_SetString(PyExc_ValueError, "strcoll arguments must be strings");
@@ -368,7 +368,7 @@
             return PyErr_NoMemory();
         strxfrm(buf, s, n2);
     }
-    result = PyBytes_FromString(buf);
+    result = PyString_FromString(buf);
     PyMem_Free(buf);
     return result;
 }
@@ -563,13 +563,13 @@
         return NULL;
     /* Check whether this is a supported constant. GNU libc sometimes
        returns numeric values in the char* return value, which would
-       crash PyBytes_FromString.  */
+       crash PyString_FromString.  */
     for (i = 0; langinfo_constants[i].name; i++)
         if (langinfo_constants[i].value == item) {
             /* Check NULL as a workaround for GNU libc's returning NULL
                instead of an empty string for nl_langinfo(ERA).  */
             const char *result = nl_langinfo(item);
-            return PyBytes_FromString(result != NULL ? result : "");
+            return PyString_FromString(result != NULL ? result : "");
         }
     PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");
     return NULL;
@@ -588,7 +588,7 @@
 	char *in;
 	if (!PyArg_ParseTuple(args, "z", &in))
 		return 0;
-	return PyBytes_FromString(gettext(in));
+	return PyString_FromString(gettext(in));
 }
 
 PyDoc_STRVAR(dgettext__doc__,
@@ -601,7 +601,7 @@
 	char *domain, *in;
 	if (!PyArg_ParseTuple(args, "zz", &domain, &in))
 		return 0;
-	return PyBytes_FromString(dgettext(domain, in));
+	return PyString_FromString(dgettext(domain, in));
 }
 
 PyDoc_STRVAR(dcgettext__doc__,
@@ -615,7 +615,7 @@
 	int category;
 	if (!PyArg_ParseTuple(args, "zzi", &domain, &msgid, &category))
 		return 0;
-	return PyBytes_FromString(dcgettext(domain,msgid,category));
+	return PyString_FromString(dcgettext(domain,msgid,category));
 }
 
 PyDoc_STRVAR(textdomain__doc__,
@@ -633,7 +633,7 @@
 		PyErr_SetFromErrno(PyExc_OSError);
 		return NULL;
 	}
-	return PyBytes_FromString(domain);
+	return PyString_FromString(domain);
 }
 
 PyDoc_STRVAR(bindtextdomain__doc__,
@@ -651,7 +651,7 @@
 		PyErr_SetFromErrno(PyExc_OSError);
 		return NULL;
 	}
-	return PyBytes_FromString(dirname);
+	return PyString_FromString(dirname);
 }
 
 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
@@ -667,7 +667,7 @@
 		return NULL;
 	codeset = bind_textdomain_codeset(domain, codeset);
 	if (codeset)
-		return PyBytes_FromString(codeset);
+		return PyString_FromString(codeset);
 	Py_RETURN_NONE;
 }
 #endif
@@ -760,7 +760,7 @@
     Error = PyErr_NewException("locale.Error", NULL, NULL);
     PyDict_SetItemString(d, "Error", Error);
 
-    x = PyBytes_FromString(locale__doc__);
+    x = PyString_FromString(locale__doc__);
     PyDict_SetItemString(d, "__doc__", x);
     Py_XDECREF(x);
 
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
index 2b80a00..5d18c33 100644
--- a/Modules/_lsprof.c
+++ b/Modules/_lsprof.c
@@ -179,8 +179,8 @@
 		/* built-in function: look up the module name */
 		PyObject *mod = fn->m_module;
 		char *modname;
-		if (mod && PyBytes_Check(mod)) {
-			modname = PyBytes_AS_STRING(mod);
+		if (mod && PyString_Check(mod)) {
+			modname = PyString_AS_STRING(mod);
 		}
 		else if (mod && PyModule_Check(mod)) {
 			modname = PyModule_GetName(mod);
@@ -193,11 +193,11 @@
 			modname = "__builtin__";
 		}
 		if (strcmp(modname, "__builtin__") != 0)
-			return PyBytes_FromFormat("<%s.%s>",
+			return PyString_FromFormat("<%s.%s>",
 						   modname,
 						   fn->m_ml->ml_name);
 		else
-			return PyBytes_FromFormat("<%s>",
+			return PyString_FromFormat("<%s>",
 						   fn->m_ml->ml_name);
 	}
 	else {
@@ -205,7 +205,7 @@
 			repr(getattr(type(__self__), __name__))
 		*/
 		PyObject *self = fn->m_self;
-		PyObject *name = PyBytes_FromString(fn->m_ml->ml_name);
+		PyObject *name = PyString_FromString(fn->m_ml->ml_name);
 		if (name != NULL) {
 			PyObject *mo = _PyType_Lookup(Py_TYPE(self), name);
 			Py_XINCREF(mo);
@@ -218,7 +218,7 @@
 			}
 		}
 		PyErr_Clear();
-		return PyBytes_FromFormat("<built-in method %s>",
+		return PyString_FromFormat("<built-in method %s>",
 					   fn->m_ml->ml_name);
 	}
 }
diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c
index 3362a5c..85118fc 100644
--- a/Modules/_sqlite/cache.c
+++ b/Modules/_sqlite/cache.c
@@ -241,12 +241,12 @@
         if (!fmt_args) {
             return NULL;
         }
-        template = PyBytes_FromString("%s <- %s ->%s\n");
+        template = PyString_FromString("%s <- %s ->%s\n");
         if (!template) {
             Py_DECREF(fmt_args);
             return NULL;
         }
-        display_str = PyBytes_Format(template, fmt_args);
+        display_str = PyString_Format(template, fmt_args);
         Py_DECREF(template);
         Py_DECREF(fmt_args);
         if (!display_str) {
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 927c983..8269e0b 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -84,8 +84,8 @@
     Py_INCREF(&PyUnicode_Type);
     self->text_factory = (PyObject*)&PyUnicode_Type;
 
-    if (PyBytes_Check(database) || PyUnicode_Check(database)) {
-        if (PyBytes_Check(database)) {
+    if (PyString_Check(database) || PyUnicode_Check(database)) {
+        if (PyString_Check(database)) {
             database_utf8 = database;
             Py_INCREF(database_utf8);
         } else {
@@ -96,7 +96,7 @@
         }
 
         Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_open(PyBytes_AsString(database_utf8), &self->db);
+        rc = sqlite3_open(PyString_AsString(database_utf8), &self->db);
         Py_END_ALLOW_THREADS
 
         Py_DECREF(database_utf8);
@@ -111,7 +111,7 @@
         if (class_attr) {
             class_attr_str = PyObject_Str(class_attr);
             if (class_attr_str) {
-                if (strcmp(PyBytes_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {
+                if (strcmp(PyString_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {
                     /* In the APSW Connection object, the first entry after
                      * PyObject_HEAD is the sqlite3* we want to get hold of.
                      * Luckily, this is the same layout as we have in our
@@ -134,7 +134,7 @@
     }
 
     if (!isolation_level) {
-        isolation_level = PyBytes_FromString("");
+        isolation_level = PyString_FromString("");
         if (!isolation_level) {
             return -1;
         }
@@ -499,12 +499,12 @@
         } else {
             sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);
         }
-    } else if (PyBytes_Check(py_val)) {
-        sqlite3_result_text(context, PyBytes_AsString(py_val), -1, SQLITE_TRANSIENT);
+    } else if (PyString_Check(py_val)) {
+        sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);
     } else if (PyUnicode_Check(py_val)) {
         stringval = PyUnicode_AsUTF8String(py_val);
         if (stringval) {
-            sqlite3_result_text(context, PyBytes_AsString(stringval), -1, SQLITE_TRANSIENT);
+            sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);
             Py_DECREF(stringval);
         }
     } else {
@@ -963,21 +963,21 @@
         Py_INCREF(isolation_level);
         self->isolation_level = isolation_level;
 
-        begin_statement = PyBytes_FromString("BEGIN ");
+        begin_statement = PyString_FromString("BEGIN ");
         if (!begin_statement) {
             return -1;
         }
-        PyBytes_Concat(&begin_statement, isolation_level);
+        PyString_Concat(&begin_statement, isolation_level);
         if (!begin_statement) {
             return -1;
         }
 
-        self->begin_statement = PyMem_Malloc(PyBytes_Size(begin_statement) + 2);
+        self->begin_statement = PyMem_Malloc(PyString_Size(begin_statement) + 2);
         if (!self->begin_statement) {
             return -1;
         }
 
-        strcpy(self->begin_statement, PyBytes_AsString(begin_statement));
+        strcpy(self->begin_statement, PyString_AsString(begin_statement));
         Py_DECREF(begin_statement);
     }
 
@@ -1152,8 +1152,8 @@
         goto finally;
     }
 
-    string1 = PyBytes_FromStringAndSize((const char*)text1_data, text1_length);
-    string2 = PyBytes_FromStringAndSize((const char*)text2_data, text2_length);
+    string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
+    string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
 
     if (!string1 || !string2) {
         goto finally; /* failed to allocate strings */
@@ -1259,7 +1259,7 @@
         goto finally;
     }
 
-    if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyBytes_Type, &name, &callable)) {
+    if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) {
         goto finally;
     }
 
@@ -1268,7 +1268,7 @@
         goto finally;
     }
 
-    chk = PyBytes_AsString(uppercase_name);
+    chk = PyString_AsString(uppercase_name);
     while (*chk) {
         if ((*chk >= '0' && *chk <= '9')
          || (*chk >= 'A' && *chk <= 'Z')
@@ -1293,7 +1293,7 @@
     }
 
     rc = sqlite3_create_collation(self->db,
-                                  PyBytes_AsString(uppercase_name),
+                                  PyString_AsString(uppercase_name),
                                   SQLITE_UTF8,
                                   (callable != Py_None) ? callable : NULL,
                                   (callable != Py_None) ? pysqlite_collation_callback : NULL);
diff --git a/Modules/_sqlite/connection.h b/Modules/_sqlite/connection.h
index c5d0fd0..3b1c632 100644
--- a/Modules/_sqlite/connection.h
+++ b/Modules/_sqlite/connection.h
@@ -80,7 +80,7 @@
     /* Determines how bytestrings from SQLite are converted to Python objects:
      * - PyUnicode_Type:        Python Unicode objects are constructed from UTF-8 bytestrings
      * - OptimizedUnicode:      Like before, but for ASCII data, only PyStrings are created.
-     * - PyBytes_Type:         PyStrings are created as-is.
+     * - PyString_Type:         PyStrings are created as-is.
      * - Any custom callable:   Any object returned from the callable called with the bytestring
      *                          as single parameter.
      */
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index 23d1e06..0d7d59a 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -178,7 +178,7 @@
                     if (*pos == '[') {
                         type_start = pos + 1;
                     } else if (*pos == ']' && type_start != (const char*)-1) {
-                        key = PyBytes_FromStringAndSize(type_start, pos - type_start);
+                        key = PyString_FromStringAndSize(type_start, pos - type_start);
                         if (!key) {
                             /* creating a string failed, but it is too complicated
                              * to propagate the error here, we just assume there is
@@ -203,7 +203,7 @@
                      * 'NUMBER(10)' to be treated as 'NUMBER', for example.
                      * In other words, it will work as people expect it to work.*/
                     if (*pos == ' ' || *pos == '(' || *pos == 0) {
-                        py_decltype = PyBytes_FromStringAndSize(decltype, pos - decltype);
+                        py_decltype = PyString_FromStringAndSize(decltype, pos - decltype);
                         if (!py_decltype) {
                             return -1;
                         }
@@ -248,7 +248,7 @@
             if ((*pos == '[') && (pos > colname) && (*(pos-1) == ' ')) {
                 pos--;
             }
-            return PyBytes_FromStringAndSize(colname, pos - colname);
+            return PyString_FromStringAndSize(colname, pos - colname);
         }
     }
 }
@@ -273,7 +273,7 @@
     }
 
     if (is_ascii) {
-        return PyBytes_FromString(val_str);
+        return PyString_FromString(val_str);
     } else {
         return PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
     }
@@ -327,7 +327,7 @@
                 Py_INCREF(Py_None);
                 converted = Py_None;
             } else {
-                item = PyBytes_FromStringAndSize(val_str, nbytes);
+                item = PyString_FromStringAndSize(val_str, nbytes);
                 if (!item) {
                     return NULL;
                 }
@@ -370,8 +370,8 @@
                                      colname , val_str);
                         PyErr_SetString(pysqlite_OperationalError, buf);
                     }
-                } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) {
-                    converted = PyBytes_FromString(val_str);
+                } else if (self->connection->text_factory == (PyObject*)&PyString_Type) {
+                    converted = PyString_FromString(val_str);
                 } else {
                     converted = PyObject_CallFunction(self->connection->text_factory, "s", val_str);
                 }
@@ -442,7 +442,7 @@
             return NULL;
         }
 
-        if (!PyBytes_Check(operation) && !PyUnicode_Check(operation)) {
+        if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
             PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
             return NULL;
         }
@@ -464,7 +464,7 @@
             return NULL;
         }
 
-        if (!PyBytes_Check(operation) && !PyUnicode_Check(operation)) {
+        if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
             PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
             return NULL;
         }
@@ -499,15 +499,15 @@
         rc = pysqlite_statement_reset(self->statement);
     }
 
-    if (PyBytes_Check(operation)) {
-        operation_cstr = PyBytes_AsString(operation);
+    if (PyString_Check(operation)) {
+        operation_cstr = PyString_AsString(operation);
     } else {
         operation_bytestr = PyUnicode_AsUTF8String(operation);
         if (!operation_bytestr) {
             goto error;
         }
 
-        operation_cstr = PyBytes_AsString(operation_bytestr);
+        operation_cstr = PyString_AsString(operation_bytestr);
     }
 
     /* reset description and rowcount */
@@ -764,15 +764,15 @@
         return NULL;
     }
 
-    if (PyBytes_Check(script_obj)) {
-        script_cstr = PyBytes_AsString(script_obj);
+    if (PyString_Check(script_obj)) {
+        script_cstr = PyString_AsString(script_obj);
     } else if (PyUnicode_Check(script_obj)) {
         script_str = PyUnicode_AsUTF8String(script_obj);
         if (!script_str) {
             return NULL;
         }
 
-        script_cstr = PyBytes_AsString(script_str);
+        script_cstr = PyString_AsString(script_str);
     } else {
         PyErr_SetString(PyExc_ValueError, "script argument must be unicode or string.");
         return NULL;
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index f77452c..af7eace 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -137,7 +137,7 @@
     /* a basic type is adapted; there's a performance optimization if that's not the case
      * (99 % of all usages) */
     if (type == &PyInt_Type || type == &PyLong_Type || type == &PyFloat_Type
-            || type == &PyBytes_Type || type == &PyUnicode_Type || type == &PyBuffer_Type) {
+            || type == &PyString_Type || type == &PyUnicode_Type || type == &PyBuffer_Type) {
         pysqlite_BaseTypeAdapted = 1;
     }
 
@@ -367,13 +367,13 @@
         Py_DECREF(tmp_obj);
     }
 
-    if (!(tmp_obj = PyBytes_FromString(PYSQLITE_VERSION))) {
+    if (!(tmp_obj = PyString_FromString(PYSQLITE_VERSION))) {
         goto error;
     }
     PyDict_SetItemString(dict, "version", tmp_obj);
     Py_DECREF(tmp_obj);
 
-    if (!(tmp_obj = PyBytes_FromString(sqlite3_libversion()))) {
+    if (!(tmp_obj = PyString_FromString(sqlite3_libversion()))) {
         goto error;
     }
     PyDict_SetItemString(dict, "sqlite_version", tmp_obj);
diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c
index 8815116..3419267 100644
--- a/Modules/_sqlite/row.c
+++ b/Modules/_sqlite/row.c
@@ -86,13 +86,13 @@
         item = PyTuple_GetItem(self->data, _idx);
         Py_XINCREF(item);
         return item;
-    } else if (PyBytes_Check(idx)) {
-        key = PyBytes_AsString(idx);
+    } else if (PyString_Check(idx)) {
+        key = PyString_AsString(idx);
 
         nitems = PyTuple_Size(self->description);
 
         for (i = 0; i < nitems; i++) {
-            compare_key = PyBytes_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
+            compare_key = PyString_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
             if (!compare_key) {
                 return NULL;
             }
diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c
index b9245f7..0e77668 100644
--- a/Modules/_sqlite/statement.c
+++ b/Modules/_sqlite/statement.c
@@ -60,7 +60,7 @@
     self->st = NULL;
     self->in_use = 0;
 
-    if (PyBytes_Check(sql)) {
+    if (PyString_Check(sql)) {
         sql_str = sql;
         Py_INCREF(sql_str);
     } else if (PyUnicode_Check(sql)) {
@@ -77,7 +77,7 @@
     self->in_weakreflist = NULL;
     self->sql = sql_str;
 
-    sql_cstr = PyBytes_AsString(sql_str);
+    sql_cstr = PyString_AsString(sql_str);
 
     rc = sqlite3_prepare(connection->db,
                          sql_cstr,
@@ -119,7 +119,7 @@
         paramtype = TYPE_LONG;
     } else if (PyFloat_CheckExact(parameter)) {
         paramtype = TYPE_FLOAT;
-    } else if (PyBytes_CheckExact(parameter)) {
+    } else if (PyString_CheckExact(parameter)) {
         paramtype = TYPE_STRING;
     } else if (PyUnicode_CheckExact(parameter)) {
         paramtype = TYPE_UNICODE;
@@ -131,7 +131,7 @@
         paramtype = TYPE_LONG;
     } else if (PyFloat_Check(parameter)) {
         paramtype = TYPE_FLOAT;
-    } else if (PyBytes_Check(parameter)) {
+    } else if (PyString_Check(parameter)) {
         paramtype = TYPE_STRING;
     } else if (PyUnicode_Check(parameter)) {
         paramtype = TYPE_UNICODE;
@@ -140,7 +140,7 @@
     }
 
     if (paramtype == TYPE_STRING && !allow_8bit_chars) {
-        string = PyBytes_AS_STRING(parameter);
+        string = PyString_AS_STRING(parameter);
         for (c = string; *c != 0; c++) {
             if (*c & 0x80) {
                 PyErr_SetString(pysqlite_ProgrammingError, "You must not use 8-bit bytestrings unless you use a text_factory that can interpret 8-bit bytestrings (like text_factory = str). It is highly recommended that you instead just switch your application to Unicode strings.");
@@ -164,12 +164,12 @@
             rc = sqlite3_bind_double(self->st, pos, PyFloat_AsDouble(parameter));
             break;
         case TYPE_STRING:
-            string = PyBytes_AS_STRING(parameter);
+            string = PyString_AS_STRING(parameter);
             rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
             break;
         case TYPE_UNICODE:
             stringval = PyUnicode_AsUTF8String(parameter);
-            string = PyBytes_AsString(stringval);
+            string = PyString_AsString(stringval);
             rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
             Py_DECREF(stringval);
             break;
@@ -197,7 +197,7 @@
     }
 
     if (PyInt_CheckExact(obj) || PyLong_CheckExact(obj) 
-            || PyFloat_CheckExact(obj) || PyBytes_CheckExact(obj)
+            || PyFloat_CheckExact(obj) || PyString_CheckExact(obj)
             || PyUnicode_CheckExact(obj) || PyBuffer_Check(obj)) {
         return 0;
     } else {
@@ -326,7 +326,7 @@
     char* sql_cstr;
     sqlite3_stmt* new_st;
 
-    sql_cstr = PyBytes_AsString(self->sql);
+    sql_cstr = PyString_AsString(self->sql);
 
     rc = sqlite3_prepare(self->db,
                          sql_cstr,
diff --git a/Modules/_sre.c b/Modules/_sre.c
index 342f9a0..808fb57 100644
--- a/Modules/_sre.c
+++ b/Modules/_sre.c
@@ -1715,7 +1715,7 @@
     size = PyObject_Length(string);
 #endif
 
-    if (PyBytes_Check(string) || bytes == size)
+    if (PyString_Check(string) || bytes == size)
         charsize = 1;
 #if defined(HAVE_UNICODE)
     else if (bytes == (Py_ssize_t) (size * sizeof(Py_UNICODE)))
@@ -1949,7 +1949,7 @@
 
     if (!args)
         return NULL;
-    name = PyBytes_FromString(module);
+    name = PyString_FromString(module);
     if (!name)
         return NULL;
     mod = PyImport_Import(name);
@@ -3416,7 +3416,7 @@
         Py_DECREF(x);
     }
 
-    x = PyBytes_FromString(copyright);
+    x = PyString_FromString(copyright);
     if (x) {
         PyDict_SetItemString(d, "copyright", x);
         Py_DECREF(x);
diff --git a/Modules/_ssl.c b/Modules/_ssl.c
index 91f16e6..3f167b3 100644
--- a/Modules/_ssl.c
+++ b/Modules/_ssl.c
@@ -491,13 +491,13 @@
 static PyObject *
 PySSL_server(PySSLObject *self)
 {
-	return PyBytes_FromString(self->server);
+	return PyString_FromString(self->server);
 }
 
 static PyObject *
 PySSL_issuer(PySSLObject *self)
 {
-	return PyBytes_FromString(self->issuer);
+	return PyString_FromString(self->issuer);
 }
 
 static PyObject *
@@ -515,7 +515,7 @@
 		_setSSLError(NULL, 0, __FILE__, __LINE__);
 		goto fail;
 	}
-	name_obj = PyBytes_FromStringAndSize(namebuf, buflen);
+	name_obj = PyString_FromStringAndSize(namebuf, buflen);
 	if (name_obj == NULL)
 		goto fail;
 	
@@ -603,8 +603,8 @@
                 /*
                 fprintf(stderr, "RDN level %d, attribute %s: %s\n",
                         entry->set,
-                        PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 0)),
-                        PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 1)));                        
+                        PyString_AS_STRING(PyTuple_GET_ITEM(attr, 0)),
+                        PyString_AS_STRING(PyTuple_GET_ITEM(attr, 1)));                        
                 */
 		if (attr == NULL)
 			goto fail1;
@@ -711,7 +711,7 @@
 					goto fail;
 				}
 
-				v = PyBytes_FromString("DirName");
+				v = PyString_FromString("DirName");
 				if (v == NULL) {
 					Py_DECREF(t);
 					goto fail;
@@ -742,13 +742,13 @@
 				t = PyTuple_New(2);
 				if (t == NULL)
 					goto fail;
-				v = PyBytes_FromStringAndSize(buf, (vptr - buf));
+				v = PyString_FromStringAndSize(buf, (vptr - buf));
 				if (v == NULL) {
 					Py_DECREF(t);
 					goto fail;
 				}
 				PyTuple_SET_ITEM(t, 0, v);
-				v = PyBytes_FromStringAndSize((vptr + 1), (len - (vptr - buf + 1)));
+				v = PyString_FromStringAndSize((vptr + 1), (len - (vptr - buf + 1)));
 				if (v == NULL) {
 					Py_DECREF(t);
 					goto fail;
@@ -849,7 +849,7 @@
 			_setSSLError(NULL, 0, __FILE__, __LINE__);
 			goto fail1;
 		}
-		sn_obj = PyBytes_FromStringAndSize(buf, len);
+		sn_obj = PyString_FromStringAndSize(buf, len);
 		if (sn_obj == NULL)
 			goto fail1;
 		if (PyDict_SetItemString(retval, "serialNumber", sn_obj) < 0) {
@@ -866,7 +866,7 @@
 			_setSSLError(NULL, 0, __FILE__, __LINE__);
 			goto fail1;
 		}
-		pnotBefore = PyBytes_FromStringAndSize(buf, len);
+		pnotBefore = PyString_FromStringAndSize(buf, len);
 		if (pnotBefore == NULL)
 			goto fail1;
 		if (PyDict_SetItemString(retval, "notBefore", pnotBefore) < 0) {
@@ -884,7 +884,7 @@
 		_setSSLError(NULL, 0, __FILE__, __LINE__);
 		goto fail1;
 	}
-	pnotAfter = PyBytes_FromStringAndSize(buf, len);
+	pnotAfter = PyString_FromStringAndSize(buf, len);
 	if (pnotAfter == NULL)
 		goto fail1;
 	if (PyDict_SetItemString(retval, "notAfter", pnotAfter) < 0) {
@@ -981,7 +981,7 @@
 			PySSL_SetError(self, len, __FILE__, __LINE__);
 			return NULL;
 		}
-		retval = PyBytes_FromStringAndSize((const char *) bytes_buf, len);
+		retval = PyString_FromStringAndSize((const char *) bytes_buf, len);
 		OPENSSL_free(bytes_buf);
 		return retval;
 
@@ -1028,7 +1028,7 @@
 	if (cipher_name == NULL) {
 		PyTuple_SET_ITEM(retval, 0, Py_None);
 	} else {
-		v = PyBytes_FromString(cipher_name);
+		v = PyString_FromString(cipher_name);
 		if (v == NULL)
 			goto fail0;
 		PyTuple_SET_ITEM(retval, 0, v);
@@ -1037,7 +1037,7 @@
 	if (cipher_protocol == NULL) {
 		PyTuple_SET_ITEM(retval, 1, Py_None);
 	} else {
-		v = PyBytes_FromString(cipher_protocol);
+		v = PyString_FromString(cipher_protocol);
 		if (v == NULL)
 			goto fail0;
 		PyTuple_SET_ITEM(retval, 1, v);
@@ -1211,7 +1211,7 @@
 	if (!PyArg_ParseTuple(args, "|i:read", &len))
 		return NULL;
 
-	if (!(buf = PyBytes_FromStringAndSize((char *) 0, len)))
+	if (!(buf = PyString_FromStringAndSize((char *) 0, len)))
 		return NULL;
 
 	/* first check if there are bytes ready to be read */
@@ -1233,14 +1233,14 @@
 			return NULL;
 		} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
 			/* should contain a zero-length string */
-			_PyBytes_Resize(&buf, 0);
+			_PyString_Resize(&buf, 0);
 			return buf;
 		}
 	}
 	do {
 		err = 0;
 		PySSL_BEGIN_ALLOW_THREADS
-		count = SSL_read(self->ssl, PyBytes_AsString(buf), len);
+		count = SSL_read(self->ssl, PyString_AsString(buf), len);
 		err = SSL_get_error(self->ssl, count);
 		PySSL_END_ALLOW_THREADS
 		if(PyErr_CheckSignals()) {
@@ -1257,7 +1257,7 @@
 			   (SSL_get_shutdown(self->ssl) ==
 			    SSL_RECEIVED_SHUTDOWN))
 		{
-			_PyBytes_Resize(&buf, 0);
+			_PyString_Resize(&buf, 0);
 			return buf;
 		} else {
 			sockstate = SOCKET_OPERATION_OK;
@@ -1276,7 +1276,7 @@
 		return PySSL_SetError(self, count, __FILE__, __LINE__);
 	}
 	if (count != len)
-		_PyBytes_Resize(&buf, count);
+		_PyString_Resize(&buf, count);
 	return buf;
 }
 
@@ -1362,11 +1362,11 @@
 {
     int bytes;
 
-    if (!PyBytes_Check(arg))
+    if (!PyString_Check(arg))
 	return PyErr_Format(PyExc_TypeError,
 			    "RAND_egd() expected string, found %s",
 			    Py_TYPE(arg)->tp_name);
-    bytes = RAND_egd(PyBytes_AS_STRING(arg));
+    bytes = RAND_egd(PyString_AS_STRING(arg));
     if (bytes == -1) {
 	PyErr_SetString(PySSLErrorObject,
 			"EGD connection failed or EGD did not return "
diff --git a/Modules/_struct.c b/Modules/_struct.c
index b0351f1..e5fe211 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -413,7 +413,7 @@
 		if (msg == NULL)
 			return -1;
 		rval = PyErr_WarnEx(PyExc_DeprecationWarning,
-				    PyBytes_AS_STRING(msg), 2);
+				    PyString_AS_STRING(msg), 2);
 		Py_DECREF(msg);
 		if (rval == 0)
 			return 0;
@@ -446,7 +446,7 @@
 static PyObject *
 nu_char(const char *p, const formatdef *f)
 {
-	return PyBytes_FromStringAndSize(p, 1);
+	return PyString_FromStringAndSize(p, 1);
 }
 
 static PyObject *
@@ -610,12 +610,12 @@
 static int
 np_char(char *p, PyObject *v, const formatdef *f)
 {
-	if (!PyBytes_Check(v) || PyBytes_Size(v) != 1) {
+	if (!PyString_Check(v) || PyString_Size(v) != 1) {
 		PyErr_SetString(StructError,
 				"char format require string of length 1");
 		return -1;
 	}
-	*p = *PyBytes_AsString(v);
+	*p = *PyString_AsString(v);
 	return 0;
 }
 
@@ -1335,7 +1335,7 @@
 	char c;
 	Py_ssize_t size, len, num, itemsize, x;
 
-	fmt = PyBytes_AS_STRING(self->s_format);
+	fmt = PyString_AS_STRING(self->s_format);
 
 	f = whichtable((char **)&fmt);
 
@@ -1503,12 +1503,12 @@
 		const formatdef *e = code->fmtdef;
 		const char *res = startfrom + code->offset;
 		if (e->format == 's') {
-			v = PyBytes_FromStringAndSize(res, code->size);
+			v = PyString_FromStringAndSize(res, code->size);
 		} else if (e->format == 'p') {
 			Py_ssize_t n = *(unsigned char*)res;
 			if (n >= code->size)
 				n = code->size - 1;
-			v = PyBytes_FromStringAndSize(res + 1, n);
+			v = PyString_FromStringAndSize(res + 1, n);
 		} else {
 			v = e->unpack(res, e);
 		}
@@ -1542,9 +1542,9 @@
 	assert(soself->s_codes != NULL);
 	if (inputstr == NULL)
 		goto fail;
-	if (PyBytes_Check(inputstr) &&
-		PyBytes_GET_SIZE(inputstr) == soself->s_size) {
-			return s_unpack_internal(soself, PyBytes_AS_STRING(inputstr));
+	if (PyString_Check(inputstr) &&
+		PyString_GET_SIZE(inputstr) == soself->s_size) {
+			return s_unpack_internal(soself, PyString_AS_STRING(inputstr));
 	}
 	args = PyTuple_Pack(1, inputstr);
 	if (args == NULL)
@@ -1637,27 +1637,27 @@
 		const formatdef *e = code->fmtdef;
 		char *res = buf + code->offset;
 		if (e->format == 's') {
-			if (!PyBytes_Check(v)) {
+			if (!PyString_Check(v)) {
 				PyErr_SetString(StructError,
 						"argument for 's' must be a string");
 				return -1;
 			}
-			n = PyBytes_GET_SIZE(v);
+			n = PyString_GET_SIZE(v);
 			if (n > code->size)
 				n = code->size;
 			if (n > 0)
-				memcpy(res, PyBytes_AS_STRING(v), n);
+				memcpy(res, PyString_AS_STRING(v), n);
 		} else if (e->format == 'p') {
-			if (!PyBytes_Check(v)) {
+			if (!PyString_Check(v)) {
 				PyErr_SetString(StructError,
 						"argument for 'p' must be a string");
 				return -1;
 			}
-			n = PyBytes_GET_SIZE(v);
+			n = PyString_GET_SIZE(v);
 			if (n > (code->size - 1))
 				n = code->size - 1;
 			if (n > 0)
-				memcpy(res + 1, PyBytes_AS_STRING(v), n);
+				memcpy(res + 1, PyString_AS_STRING(v), n);
 			if (n > 255)
 				n = 255;
 			*res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
@@ -1700,12 +1700,12 @@
 	}
 
 	/* Allocate a new string */
-	result = PyBytes_FromStringAndSize((char *)NULL, soself->s_size);
+	result = PyString_FromStringAndSize((char *)NULL, soself->s_size);
 	if (result == NULL)
 		return NULL;
 
 	/* Call the guts */
-	if ( s_pack_internal(soself, args, 0, PyBytes_AS_STRING(result)) != 0 ) {
+	if ( s_pack_internal(soself, args, 0, PyString_AS_STRING(result)) != 0 ) {
 		Py_DECREF(result);
 		return NULL;
 	}
@@ -2061,7 +2061,7 @@
 {
 	PyObject *ver, *m;
 
-	ver = PyBytes_FromString("0.2");
+	ver = PyString_FromString("0.2");
 	if (ver == NULL)
 		return;
 
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 15bd899..4a00fb1 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -691,7 +691,7 @@
 }
 #endif
 
-/* Some tests of PyBytes_FromFormat().  This needs more tests. */
+/* Some tests of PyString_FromFormat().  This needs more tests. */
 static PyObject *
 test_string_from_format(PyObject *self, PyObject *args)
 {
@@ -699,10 +699,10 @@
 	char *msg;
 
 #define CHECK_1_FORMAT(FORMAT, TYPE) 			\
-	result = PyBytes_FromFormat(FORMAT, (TYPE)1);	\
+	result = PyString_FromFormat(FORMAT, (TYPE)1);	\
 	if (result == NULL)				\
 		return NULL;				\
-	if (strcmp(PyBytes_AsString(result), "1")) {	\
+	if (strcmp(PyString_AsString(result), "1")) {	\
 		msg = FORMAT " failed at 1";		\
 		goto Fail;				\
 	}						\
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index eb67128..4308773 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -335,8 +335,8 @@
 static char *
 AsString(PyObject *value, PyObject *tmp)
 {
-	if (PyBytes_Check(value))
-		return PyBytes_AsString(value);
+	if (PyString_Check(value))
+		return PyString_AsString(value);
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(value)) {
 		PyObject *v = PyUnicode_AsUTF8String(value);
@@ -347,7 +347,7 @@
 			return NULL;
 		}
 		Py_DECREF(v);
-		return PyBytes_AsString(v);
+		return PyString_AsString(v);
 	}
 #endif
 	else {
@@ -359,7 +359,7 @@
 			return NULL;
 		}
 		Py_DECREF(v);
-		return PyBytes_AsString(v);
+		return PyString_AsString(v);
 	}
 }
 
@@ -462,13 +462,13 @@
 		 * Could be a quoted string containing funnies, e.g. {"}.
 		 * Return the string itself.
 		 */
-		return PyBytes_FromString(list);
+		return PyString_FromString(list);
 	}
 
 	if (argc == 0)
-		v = PyBytes_FromString("");
+		v = PyString_FromString("");
 	else if (argc == 1)
-		v = PyBytes_FromString(argv[0]);
+		v = PyString_FromString(argv[0]);
 	else if ((v = PyTuple_New(argc)) != NULL) {
 		int i;
 		PyObject *w;
@@ -530,10 +530,10 @@
 			return result;
 		/* Fall through, returning arg. */
 	}
-	else if (PyBytes_Check(arg)) {
+	else if (PyString_Check(arg)) {
 		int argc;
 		char **argv;
-		char *list = PyBytes_AsString(arg);
+		char *list = PyString_AsString(arg);
 
 		if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
 			Py_INCREF(arg);
@@ -541,7 +541,7 @@
 		}
 		Tcl_Free(FREECAST argv);
 		if (argc > 1)
-			return Split(PyBytes_AsString(arg));
+			return Split(PyString_AsString(arg));
 		/* Fall through, returning arg. */
 	}
 	Py_INCREF(arg);
@@ -747,12 +747,12 @@
 static PyObject *
 PyTclObject_str(PyTclObject *self)
 {
-	if (self->string && PyBytes_Check(self->string)) {
+	if (self->string && PyString_Check(self->string)) {
 		Py_INCREF(self->string);
 		return self->string;
 	}
 	/* XXX Could cache value if it is an ASCII string. */
-	return PyBytes_FromString(Tcl_GetString(self->value));
+	return PyString_FromString(Tcl_GetString(self->value));
 }
 
 static char*
@@ -778,16 +778,16 @@
 #ifdef Py_USING_UNICODE
 		if (i == len)
 			/* It is an ASCII string. */
-			self->string = PyBytes_FromStringAndSize(s, len);
+			self->string = PyString_FromStringAndSize(s, len);
 		else {
 			self->string = PyUnicode_DecodeUTF8(s, len, "strict");
 			if (!self->string) {
 				PyErr_Clear();
-				self->string = PyBytes_FromStringAndSize(s, len);
+				self->string = PyString_FromStringAndSize(s, len);
 			}
 		}
 #else
-		self->string = PyBytes_FromStringAndSize(s, len);
+		self->string = PyString_FromStringAndSize(s, len);
 #endif
 		if (!self->string)
 			return NULL;
@@ -820,7 +820,7 @@
 	char buf[50];
 	PyOS_snprintf(buf, 50, "<%s object at %p>",
 		      self->value->typePtr->name, self->value);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static int
@@ -839,7 +839,7 @@
 static PyObject*
 get_typename(PyTclObject* obj, void* ignored)
 {
-	return PyBytes_FromString(obj->value->typePtr->name);
+	return PyString_FromString(obj->value->typePtr->name);
 }
 
 
@@ -908,9 +908,9 @@
 {
 	Tcl_Obj *result;
 
-	if (PyBytes_Check(value))
-		return Tcl_NewStringObj(PyBytes_AS_STRING(value),
-					PyBytes_GET_SIZE(value));
+	if (PyString_Check(value))
+		return Tcl_NewStringObj(PyString_AS_STRING(value),
+					PyString_GET_SIZE(value));
 	else if (PyBool_Check(value))
 		return Tcl_NewBooleanObj(PyObject_IsTrue(value));
 	else if (PyInt_Check(value))
@@ -999,17 +999,17 @@
 		}
 
 		if (i == value->length)
-			result = PyBytes_FromStringAndSize(s, len);
+			result = PyString_FromStringAndSize(s, len);
 		else {
 			/* Convert UTF-8 to Unicode string */
 			result = PyUnicode_DecodeUTF8(s, len, "strict");
 			if (result == NULL) {
 				PyErr_Clear();
-				result = PyBytes_FromStringAndSize(s, len);
+				result = PyString_FromStringAndSize(s, len);
 			}
 		}
 #else
-		result = PyBytes_FromStringAndSize(value->bytes, value->length);
+		result = PyString_FromStringAndSize(value->bytes, value->length);
 #endif
 		return result;
 	}
@@ -1023,7 +1023,7 @@
 	if (value->typePtr == app->ByteArrayType) {
 		int size;
 		char *data = (char*)Tcl_GetByteArrayFromObj(value, &size);
-		return PyBytes_FromStringAndSize(data, size);
+		return PyString_FromStringAndSize(data, size);
 	}
 
 	if (value->typePtr == app->DoubleType) {
@@ -1092,7 +1092,7 @@
 		int size;
 		char *c;
 		c = Tcl_GetStringFromObj(value, &size);
-		return PyBytes_FromStringAndSize(c, size);
+		return PyString_FromStringAndSize(c, size);
 #endif
 	}
 
@@ -1204,19 +1204,19 @@
 		}
 
 		if (*p == '\0')
-			res = PyBytes_FromStringAndSize(s, (int)(p-s));
+			res = PyString_FromStringAndSize(s, (int)(p-s));
 		else {
 			/* Convert UTF-8 to Unicode string */
 			p = strchr(p, '\0');
 			res = PyUnicode_DecodeUTF8(s, (int)(p-s), "strict");
 			if (res == NULL) {
 				PyErr_Clear();
-				res = PyBytes_FromStringAndSize(s, (int)(p-s));
+				res = PyString_FromStringAndSize(s, (int)(p-s));
 			}
 		}
 #else
 		p = strchr(p, '\0');
-		res = PyBytes_FromStringAndSize(s, (int)(p-s));
+		res = PyString_FromStringAndSize(s, (int)(p-s));
 #endif
 	}
 	return res;
@@ -1370,7 +1370,7 @@
 		if (err == TCL_ERROR)
 			res = Tkinter_Error(self);
 		else
-			res = PyBytes_FromString(Tkapp_Result(self));
+			res = PyString_FromString(Tkapp_Result(self));
 		LEAVE_OVERLAP_TCL
 		ckfree(cmd);
 	}
@@ -1396,7 +1396,7 @@
 	if (err == TCL_ERROR)
 		res = Tkinter_Error(self);
 	else
-		res = PyBytes_FromString(Tkapp_Result(self));
+		res = PyString_FromString(Tkapp_Result(self));
 	LEAVE_OVERLAP_TCL
 	return res;
 }
@@ -1419,7 +1419,7 @@
 	if (err == TCL_ERROR)
 		res = Tkinter_Error(self);
 	else
-		res = PyBytes_FromString(Tkapp_Result(self));
+		res = PyString_FromString(Tkapp_Result(self));
 	LEAVE_OVERLAP_TCL
 	return res;
 }
@@ -1443,7 +1443,7 @@
 		res = Tkinter_Error(self);
 
 	else
-		res = PyBytes_FromString(Tkapp_Result(self));
+		res = PyString_FromString(Tkapp_Result(self));
 	LEAVE_OVERLAP_TCL
 	return res;
 }
@@ -1466,7 +1466,7 @@
 	if (err == TCL_ERROR)
 		res = Tkinter_Error(self);
 	else
-		res = PyBytes_FromString(Tkapp_Result(self));
+		res = PyString_FromString(Tkapp_Result(self));
 	LEAVE_OVERLAP_TCL
 	return res;
 }
@@ -1511,8 +1511,8 @@
 varname_converter(PyObject *in, void *_out)
 {
 	char **out = (char**)_out;
-	if (PyBytes_Check(in)) {
-		*out = PyBytes_AsString(in);
+	if (PyString_Check(in)) {
+		*out = PyString_AsString(in);
 		return 1;
 	}
 	if (PyTclObject_Check(in)) {
@@ -1676,7 +1676,7 @@
 			res = FromObj(self, tres);
 		}
 		else {
-			res = PyBytes_FromString(Tcl_GetString(tres));
+			res = PyString_FromString(Tcl_GetString(tres));
 		}
 	}
 	LEAVE_OVERLAP_TCL
@@ -1920,7 +1920,7 @@
 		goto finally;
 
 	for (i = 0; i < argc; i++) {
-		PyObject *s = PyBytes_FromString(argv[i]);
+		PyObject *s = PyString_FromString(argv[i]);
 		if (!s || PyTuple_SetItem(v, i, s)) {
 			Py_DECREF(v);
 			v = NULL;
@@ -1961,7 +1961,7 @@
 	PyObject *res = NULL;
 
 	if (s) {
-		res = PyBytes_FromString(s);
+		res = PyString_FromString(s);
 		ckfree(s);
 	}
 
@@ -2011,7 +2011,7 @@
 		return PythonCmd_Error(interp);
 
 	for (i = 0; i < (argc - 1); i++) {
-		PyObject *s = PyBytes_FromString(argv[i + 1]);
+		PyObject *s = PyString_FromString(argv[i + 1]);
 		if (!s || PyTuple_SetItem(arg, i, s)) {
 			Py_DECREF(arg);
 			return PythonCmd_Error(interp);
@@ -2406,7 +2406,7 @@
 
 	PyOS_snprintf(buf, sizeof(buf), "<tktimertoken at %p%s>", v,
 	                v->func == NULL ? ", handler deleted" : "");
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyObject *
@@ -3087,7 +3087,7 @@
 static void
 ins_string(PyObject *d, char *name, char *val)
 {
-	PyObject *v = PyBytes_FromString(val);
+	PyObject *v = PyString_FromString(val);
 	if (v) {
 		PyDict_SetItemString(d, name, v);
 		Py_DECREF(v);
diff --git a/Modules/almodule.c b/Modules/almodule.c
index 60140ae..7f48fff 100644
--- a/Modules/almodule.c
+++ b/Modules/almodule.c
@@ -84,7 +84,7 @@
 			Py_INCREF(Py_None);
 			return Py_None;
 		}
-		return PyBytes_FromString((char *) value.ptr);
+		return PyString_FromString((char *) value.ptr);
 	default:
 		PyErr_SetString(ErrorObject, "unknown element type");
 		return NULL;
@@ -149,12 +149,12 @@
 			PyErr_SetString(ErrorObject, "unknown element type");
 			return -1;
 		}
-		if (!PyBytes_Check(value)) {
+		if (!PyString_Check(value)) {
 			PyErr_BadArgument();
 			return -1;
 		}
-		param->value.ptr = PyBytes_AS_STRING(value);
-		param->sizeIn = PyBytes_GET_SIZE(value)+1; /*account for NUL*/
+		param->value.ptr = PyString_AS_STRING(value);
+		param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
 		break;
 	case AL_SET_VAL:
 	case AL_VECTOR_VAL:
@@ -765,12 +765,12 @@
 		return NULL;
 	}
 	size *= ch;
-	v = PyBytes_FromStringAndSize((char *) NULL, size * framecount);
+	v = PyString_FromStringAndSize((char *) NULL, size * framecount);
 	if (v == NULL)
 		return NULL;
 
 	Py_BEGIN_ALLOW_THREADS
-	alReadFrames(self->port, (void *) PyBytes_AS_STRING(v), framecount);
+	alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
 	Py_END_ALLOW_THREADS
 
 	return v;
@@ -1068,12 +1068,12 @@
 	width = ALgetwidth(c);
 #endif /* AL_405 */
 	ALfreeconfig(c);
-	v = PyBytes_FromStringAndSize((char *)NULL, width * count);
+	v = PyString_FromStringAndSize((char *)NULL, width * count);
 	if (v == NULL)
 		return NULL;
 
 	Py_BEGIN_ALLOW_THREADS
-	ret = ALreadsamps(self->port, (void *) PyBytes_AsString(v), count);
+	ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
 	Py_END_ALLOW_THREADS
 	if (ret == -1) {
 		Py_DECREF(v);
@@ -1498,7 +1498,7 @@
 			Py_INCREF(item);
 			break;
 		case AL_STRING_VAL:
-			item = PyBytes_FromString(pvs[i].value.ptr);
+			item = PyString_FromString(pvs[i].value.ptr);
 			PyMem_DEL(pvs[i].value.ptr);
 			break;
 		case AL_MATRIX_VAL:
@@ -1725,7 +1725,7 @@
 	PyDict_SetItemString(v, "elementType", item);
 	Py_DECREF(item);
 
-	item = PyBytes_FromString(pinfo.name);
+	item = PyString_FromString(pinfo.name);
 	PyDict_SetItemString(v, "name", item);
 	Py_DECREF(item);
 
@@ -1920,7 +1920,7 @@
 		return NULL;
 	if ((name = ALgetname(device, descriptor)) == NULL)
 		return NULL;
-	return PyBytes_FromString(name);
+	return PyString_FromString(name);
 }
 
 static PyObject *
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 32d34c7..89ed27a 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -104,7 +104,7 @@
 static PyObject *
 c_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyBytes_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
+	return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
 }
 
 static int
@@ -1414,7 +1414,7 @@
 static PyObject *
 array_tostring(arrayobject *self, PyObject *unused)
 {
-	return PyBytes_FromStringAndSize(self->ob_item,
+	return PyString_FromStringAndSize(self->ob_item,
 				    Py_SIZE(self) * self->ob_descr->itemsize);
 }
 
@@ -1494,7 +1494,7 @@
 array_get_typecode(arrayobject *a, void *closure)
 {
 	char tc = a->ob_descr->typecode;
-	return PyBytes_FromStringAndSize(&tc, 1);
+	return PyString_FromStringAndSize(&tc, 1);
 }
 
 static PyObject *
@@ -1578,7 +1578,7 @@
 	typecode = a->ob_descr->typecode;
 	if (len == 0) {
 		PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
-		return PyBytes_FromString(buf);
+		return PyString_FromString(buf);
 	}
 		
 	if (typecode == 'c')
@@ -1593,9 +1593,9 @@
 	Py_XDECREF(v);
 
 	PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
-	s = PyBytes_FromString(buf);
-	PyBytes_ConcatAndDel(&s, t);
-	PyBytes_ConcatAndDel(&s, PyBytes_FromString(")"));
+	s = PyString_FromString(buf);
+	PyString_ConcatAndDel(&s, t);
+	PyString_ConcatAndDel(&s, PyString_FromString(")"));
 	return s;
 }
 
@@ -1881,7 +1881,7 @@
 		return NULL;
 
 	if (!(initial == NULL || PyList_Check(initial)
-	      || PyBytes_Check(initial) || PyTuple_Check(initial)
+	      || PyString_Check(initial) || PyTuple_Check(initial)
 	      || (c == 'u' && PyUnicode_Check(initial)))) {
 		it = PyObject_GetIter(initial);
 		if (it == NULL)
@@ -1924,7 +1924,7 @@
 					}
 					Py_DECREF(v);
 				}
-			} else if (initial != NULL && PyBytes_Check(initial)) {
+			} else if (initial != NULL && PyString_Check(initial)) {
 				PyObject *t_initial, *v;
 				t_initial = PyTuple_Pack(1, initial);
 				if (t_initial == NULL) {
diff --git a/Modules/audioop.c b/Modules/audioop.c
index 9eb684b..ce00975 100644
--- a/Modules/audioop.c
+++ b/Modules/audioop.c
@@ -474,7 +474,7 @@
 
 	/* Passing a short** for an 's' argument is correct only
 	   if the string contents is aligned for interpretation
-	   as short[]. Due to the definition of PyBytesObject,
+	   as short[]. Due to the definition of PyStringObject,
 	   this is currently (Python 2.6) the case. */
         if ( !PyArg_ParseTuple(args, "s#s#:findfit",
 	                       (char**)&cp1, &len1, (char**)&cp2, &len2) )
@@ -759,10 +759,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len);
+        rv = PyString_FromStringAndSize(NULL, len);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
     
         for ( i=0; i < len; i += size ) {
@@ -801,10 +801,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len/2);
+        rv = PyString_FromStringAndSize(NULL, len/2);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
     
         for ( i=0; i < len; i += size*2 ) {
@@ -846,10 +846,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len*2);
+        rv = PyString_FromStringAndSize(NULL, len*2);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
     
         for ( i=0; i < len; i += size ) {
@@ -903,10 +903,10 @@
                 return 0;
         }
 
-        rv = PyBytes_FromStringAndSize(NULL, len1);
+        rv = PyString_FromStringAndSize(NULL, len1);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
 
         for ( i=0; i < len1; i += size ) {
                 if ( size == 1 )      val1 = (int)*CHARP(cp1, i);
@@ -949,10 +949,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len);
+        rv = PyString_FromStringAndSize(NULL, len);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
     
         for ( i=0; i < len; i += size ) {
@@ -985,10 +985,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len);
+        rv = PyString_FromStringAndSize(NULL, len);
         if ( rv == 0 )
                 return 0;
-        ncp = (unsigned char *)PyBytes_AsString(rv);
+        ncp = (unsigned char *)PyString_AsString(rv);
     
         for ( i=0; i < len; i += size ) {
                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;
@@ -1023,10 +1023,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, (len/size)*size2);
+        rv = PyString_FromStringAndSize(NULL, (len/size)*size2);
         if ( rv == 0 )
                 return 0;
-        ncp = (unsigned char *)PyBytes_AsString(rv);
+        ncp = (unsigned char *)PyString_AsString(rv);
     
         for ( i=0, j=0; i < len; i += size, j += size2 ) {
                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;
@@ -1157,7 +1157,7 @@
                     nbytes / bytes_per_frame != ceiling)
                         str = NULL;
                 else
-                        str = PyBytes_FromStringAndSize(NULL, nbytes);
+                        str = PyString_FromStringAndSize(NULL, nbytes);
 
                 if (str == NULL) {
                         PyErr_SetString(PyExc_MemoryError,
@@ -1165,7 +1165,7 @@
                         goto exit;
                 }
         }
-        ncp = PyBytes_AsString(str);
+        ncp = PyString_AsString(str);
 
         for (;;) {
                 while (d < 0) {
@@ -1182,13 +1182,13 @@
                                         goto exit;
                                 /* We have checked before that the length
                                  * of the string fits into int. */
-                                len = (int)(ncp - PyBytes_AsString(str));
+                                len = (int)(ncp - PyString_AsString(str));
                                 if (len == 0) {
                                         /*don't want to resize to zero length*/
-                                        rv = PyBytes_FromStringAndSize("", 0);
+                                        rv = PyString_FromStringAndSize("", 0);
                                         Py_DECREF(str);
                                         str = rv;
-                                } else if (_PyBytes_Resize(&str, len) < 0)
+                                } else if (_PyString_Resize(&str, len) < 0)
                                         goto exit;
                                 rv = Py_BuildValue("(O(iO))", str, d, samps);
                                 Py_DECREF(samps);
@@ -1255,10 +1255,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len/size);
+        rv = PyString_FromStringAndSize(NULL, len/size);
         if ( rv == 0 )
                 return 0;
-        ncp = (unsigned char *)PyBytes_AsString(rv);
+        ncp = (unsigned char *)PyString_AsString(rv);
     
         for ( i=0; i < len; i += size ) {
                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;
@@ -1289,10 +1289,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len*size);
+        rv = PyString_FromStringAndSize(NULL, len*size);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
         for ( i=0; i < len*size; i += size ) {
                 cval = *cp++;
@@ -1323,10 +1323,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len/size);
+        rv = PyString_FromStringAndSize(NULL, len/size);
         if ( rv == 0 )
                 return 0;
-        ncp = (unsigned char *)PyBytes_AsString(rv);
+        ncp = (unsigned char *)PyString_AsString(rv);
     
         for ( i=0; i < len; i += size ) {
                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;
@@ -1357,10 +1357,10 @@
                 return 0;
         }
     
-        rv = PyBytes_FromStringAndSize(NULL, len*size);
+        rv = PyString_FromStringAndSize(NULL, len*size);
         if ( rv == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(rv);
+        ncp = (signed char *)PyString_AsString(rv);
     
         for ( i=0; i < len*size; i += size ) {
                 cval = *cp++;
@@ -1393,10 +1393,10 @@
                 return 0;
         }
     
-        str = PyBytes_FromStringAndSize(NULL, len/(size*2));
+        str = PyString_FromStringAndSize(NULL, len/(size*2));
         if ( str == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(str);
+        ncp = (signed char *)PyString_AsString(str);
 
         /* Decode state, should have (value, step) */
         if ( state == Py_None ) {
@@ -1509,10 +1509,10 @@
         } else if ( !PyArg_ParseTuple(state, "ii", &valpred, &index) )
                 return 0;
     
-        str = PyBytes_FromStringAndSize(NULL, len*size*2);
+        str = PyString_FromStringAndSize(NULL, len*size*2);
         if ( str == 0 )
                 return 0;
-        ncp = (signed char *)PyBytes_AsString(str);
+        ncp = (signed char *)PyString_AsString(str);
 
         step = stepsizeTable[index];
         bufferstep = 0;
diff --git a/Modules/binascii.c b/Modules/binascii.c
index f9df625..c1fc675 100644
--- a/Modules/binascii.c
+++ b/Modules/binascii.c
@@ -141,7 +141,7 @@
 #define BASE64_PAD '='
 
 /* Max binary chunk size; limited only by available memory */
-#define BASE64_MAXBIN (INT_MAX/2 - sizeof(PyBytesObject) - 3)
+#define BASE64_MAXBIN (INT_MAX/2 - sizeof(PyStringObject) - 3)
 
 static unsigned char table_b2a_base64[] =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -203,9 +203,9 @@
 	ascii_len--;
 
 	/* Allocate the buffer */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
 		return NULL;
-	bin_data = (unsigned char *)PyBytes_AsString(rv);
+	bin_data = (unsigned char *)PyString_AsString(rv);
 
 	for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
 		/* XXX is it really best to add NULs if there's no more data */
@@ -280,9 +280,9 @@
 	}
 
 	/* We're lazy and allocate to much (fixed up later) */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
 		return NULL;
-	ascii_data = (unsigned char *)PyBytes_AsString(rv);
+	ascii_data = (unsigned char *)PyString_AsString(rv);
 
 	/* Store the length */
 	*ascii_data++ = ' ' + (bin_len & 077);
@@ -304,8 +304,8 @@
 	}
 	*ascii_data++ = '\n';	/* Append a courtesy newline */
 
-	_PyBytes_Resize(&rv, (ascii_data -
-			       (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(&rv, (ascii_data -
+			       (unsigned char *)PyString_AsString(rv)));
 	return rv;
 }
 
@@ -354,9 +354,9 @@
 	bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
 
 	/* Allocate the buffer */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
 		return NULL;
-	bin_data = (unsigned char *)PyBytes_AsString(rv);
+	bin_data = (unsigned char *)PyString_AsString(rv);
 	bin_len = 0;
 
 	for( ; ascii_len > 0; ascii_len--, ascii_data++) {
@@ -415,13 +415,13 @@
 
 	/* And set string size correctly. If the result string is empty
 	** (because the input was all invalid) return the shared empty
-	** string instead; _PyBytes_Resize() won't do this for us.
+	** string instead; _PyString_Resize() won't do this for us.
 	*/
 	if (bin_len > 0)
-		_PyBytes_Resize(&rv, bin_len);
+		_PyString_Resize(&rv, bin_len);
 	else {
 		Py_DECREF(rv);
-		rv = PyBytes_FromString("");
+		rv = PyString_FromString("");
 	}
 	return rv;
 }
@@ -448,9 +448,9 @@
 	/* We're lazy and allocate too much (fixed up later).
 	   "+3" leaves room for up to two pad characters and a trailing
 	   newline.  Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
 		return NULL;
-	ascii_data = (unsigned char *)PyBytes_AsString(rv);
+	ascii_data = (unsigned char *)PyString_AsString(rv);
 
 	for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
 		/* Shift the data into our buffer */
@@ -474,8 +474,8 @@
 	}
 	*ascii_data++ = '\n';	/* Append a courtesy newline */
 
-	_PyBytes_Resize(&rv, (ascii_data -
-			       (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(&rv, (ascii_data -
+			       (unsigned char *)PyString_AsString(rv)));
 	return rv;
 }
 
@@ -498,9 +498,9 @@
 	/* Allocate a string that is too big (fixed later) 
 	   Add two to the initial length to prevent interning which
 	   would preclude subsequent resizing.  */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, len+2)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, len+2)) == NULL )
 		return NULL;
-	bin_data = (unsigned char *)PyBytes_AsString(rv);
+	bin_data = (unsigned char *)PyString_AsString(rv);
 
 	for( ; len > 0 ; len--, ascii_data++ ) {
 		/* Get the byte and look it up */
@@ -534,8 +534,8 @@
 		Py_DECREF(rv);
 		return NULL;
 	}
-	_PyBytes_Resize(
-		&rv, (bin_data - (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(
+		&rv, (bin_data - (unsigned char *)PyString_AsString(rv)));
 	if (rv) {
 		PyObject *rrv = Py_BuildValue("Oi", rv, done);
 		Py_DECREF(rv);
@@ -559,9 +559,9 @@
 		return NULL;
 
 	/* Worst case: output is twice as big as input (fixed later) */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
 		return NULL;
-	out_data = (unsigned char *)PyBytes_AsString(rv);
+	out_data = (unsigned char *)PyString_AsString(rv);
 
 	for( in=0; in<len; in++) {
 		ch = in_data[in];
@@ -587,8 +587,8 @@
 			}
 		}
 	}
-	_PyBytes_Resize(&rv, (out_data -
-			       (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(&rv, (out_data -
+			       (unsigned char *)PyString_AsString(rv)));
 	return rv;
 }
 
@@ -608,9 +608,9 @@
 		return NULL;
 
 	/* Allocate a buffer that is at least large enough */
-	if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
 		return NULL;
-	ascii_data = (unsigned char *)PyBytes_AsString(rv);
+	ascii_data = (unsigned char *)PyString_AsString(rv);
 
 	for( ; len > 0 ; len--, bin_data++ ) {
 		/* Shift into our buffer, and output any 6bits ready */
@@ -627,8 +627,8 @@
 		leftchar <<= (6-leftbits);
 		*ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
 	}
-	_PyBytes_Resize(&rv, (ascii_data -
-			       (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(&rv, (ascii_data -
+			       (unsigned char *)PyString_AsString(rv)));
 	return rv;
 }
 
@@ -647,14 +647,14 @@
 
 	/* Empty string is a special case */
 	if ( in_len == 0 )
-		return PyBytes_FromString("");
+		return PyString_FromString("");
 
 	/* Allocate a buffer of reasonable size. Resized when needed */
 	out_len = in_len*2;
-	if ( (rv=PyBytes_FromStringAndSize(NULL, out_len)) == NULL )
+	if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL )
 		return NULL;
 	out_len_left = out_len;
-	out_data = (unsigned char *)PyBytes_AsString(rv);
+	out_data = (unsigned char *)PyString_AsString(rv);
 
 	/*
 	** We need two macros here to get/put bytes and handle
@@ -673,9 +673,9 @@
 #define OUTBYTE(b) \
 	do { \
 		 if ( --out_len_left < 0 ) { \
-			  _PyBytes_Resize(&rv, 2*out_len); \
+			  _PyString_Resize(&rv, 2*out_len); \
 			  if ( rv == NULL ) return NULL; \
-			  out_data = (unsigned char *)PyBytes_AsString(rv) \
+			  out_data = (unsigned char *)PyString_AsString(rv) \
 								 + out_len; \
 			  out_len_left = out_len-1; \
 			  out_len = out_len * 2; \
@@ -723,8 +723,8 @@
 			OUTBYTE(in_byte);
 		}
 	}
-	_PyBytes_Resize(&rv, (out_data -
-			       (unsigned char *)PyBytes_AsString(rv)));
+	_PyString_Resize(&rv, (out_data -
+			       (unsigned char *)PyString_AsString(rv)));
 	return rv;
 }
 
@@ -923,10 +923,10 @@
 	if (!PyArg_ParseTuple(args, "s#:b2a_hex", &argbuf, &arglen))
 		return NULL;
 
-	retval = PyBytes_FromStringAndSize(NULL, arglen*2);
+	retval = PyString_FromStringAndSize(NULL, arglen*2);
 	if (!retval)
 		return NULL;
-	retbuf = PyBytes_AsString(retval);
+	retbuf = PyString_AsString(retval);
 	if (!retbuf)
 		goto finally;
 
@@ -989,10 +989,10 @@
 		return NULL;
 	}
 
-	retval = PyBytes_FromStringAndSize(NULL, (arglen/2));
+	retval = PyString_FromStringAndSize(NULL, (arglen/2));
 	if (!retval)
 		return NULL;
-	retbuf = PyBytes_AsString(retval);
+	retbuf = PyString_AsString(retval);
 	if (!retbuf)
 		goto finally;
 
@@ -1106,7 +1106,7 @@
 			out++;
 		}
 	}
-	if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+	if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
 		PyMem_Free(odata);
 		return NULL;
 	}
@@ -1306,7 +1306,7 @@
 			}
 		}
 	}
-	if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+	if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
 		PyMem_Free(odata);
 		return NULL;
 	}
@@ -1354,7 +1354,7 @@
 		return;
 
 	d = PyModule_GetDict(m);
-	x = PyBytes_FromString(doc_binascii);
+	x = PyString_FromString(doc_binascii);
 	PyDict_SetItemString(d, "__doc__", x);
 	Py_XDECREF(x);
 
diff --git a/Modules/bsddbmodule.c b/Modules/bsddbmodule.c
index aca591e..0972882 100644
--- a/Modules/bsddbmodule.c
+++ b/Modules/bsddbmodule.c
@@ -312,7 +312,7 @@
 		return NULL;
 	}
 
-	result = PyBytes_FromStringAndSize(data, (int)drec.size);
+	result = PyString_FromStringAndSize(data, (int)drec.size);
 	if (data != buf) free(data);
 	return result;
 }
@@ -424,7 +424,7 @@
 		if (dp->di_type == DB_RECNO)
 			item = PyInt_FromLong(*((int*)data));
 		else
-			item = PyBytes_FromStringAndSize(data,
+			item = PyString_FromStringAndSize(data,
 							  (int)krec.size);
 		if (data != buf) free(data);
 		if (item == NULL) {
diff --git a/Modules/bz2module.c b/Modules/bz2module.c
index ee24b5d..bbabe10 100644
--- a/Modules/bz2module.c
+++ b/Modules/bz2module.c
@@ -34,7 +34,7 @@
 #error "Large file support, but neither off_t nor fpos_t is large enough."
 #endif
 
-#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
+#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
 
 #define MODE_CLOSED   0
 #define MODE_READ     1
@@ -241,7 +241,7 @@
 	int univ_newline = f->f_univ_newline;
 
 	total_v_size = n > 0 ? n : 100;
-	v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
+	v = PyString_FromStringAndSize((char *)NULL, total_v_size);
 	if (v == NULL)
 		return NULL;
 
@@ -307,7 +307,7 @@
 			Py_DECREF(v);
 			return NULL;
 		}
-		if (_PyBytes_Resize(&v, total_v_size) < 0)
+		if (_PyString_Resize(&v, total_v_size) < 0)
 			return NULL;
 		buf = BUF(v) + used_v_size;
 		end = BUF(v) + total_v_size;
@@ -315,7 +315,7 @@
 
 	used_v_size = buf - BUF(v);
 	if (used_v_size != total_v_size)
-		_PyBytes_Resize(&v, used_v_size);
+		_PyString_Resize(&v, used_v_size);
 	return v;
 }
 
@@ -438,10 +438,10 @@
 
 /* This is a hacked version of Python's
  * fileobject.c:readahead_get_line_skip(). */
-static PyBytesObject *
+static PyStringObject *
 Util_ReadAheadGetLineSkip(BZ2FileObject *f, int skip, int bufsize)
 {
-	PyBytesObject* s;
+	PyStringObject* s;
 	char *bufptr;
 	char *buf;
 	int len;
@@ -452,17 +452,17 @@
 
 	len = f->f_bufend - f->f_bufptr;
 	if (len == 0)
-		return (PyBytesObject *)
-			PyBytes_FromStringAndSize(NULL, skip);
+		return (PyStringObject *)
+			PyString_FromStringAndSize(NULL, skip);
 	bufptr = memchr(f->f_bufptr, '\n', len);
 	if (bufptr != NULL) {
 		bufptr++;			/* Count the '\n' */
 		len = bufptr - f->f_bufptr;
-		s = (PyBytesObject *)
-			PyBytes_FromStringAndSize(NULL, skip+len);
+		s = (PyStringObject *)
+			PyString_FromStringAndSize(NULL, skip+len);
 		if (s == NULL)
 			return NULL;
-		memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
+		memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
 		f->f_bufptr = bufptr;
 		if (bufptr == f->f_bufend)
 			Util_DropReadAhead(f);
@@ -476,7 +476,7 @@
 		        PyMem_Free(buf);
 			return NULL;
 		}
-		memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
+		memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
 		PyMem_Free(buf);
 	}
 	return s;
@@ -509,7 +509,7 @@
 		case MODE_READ:
 			break;
 		case MODE_READ_EOF:
-			ret = PyBytes_FromString("");
+			ret = PyString_FromString("");
 			goto cleanup;
 		case MODE_CLOSED:
 			PyErr_SetString(PyExc_ValueError,
@@ -531,7 +531,7 @@
 				"more than a Python string can hold");
 		goto cleanup;
 	}
-	ret = PyBytes_FromStringAndSize((char *)NULL, buffersize);
+	ret = PyString_FromStringAndSize((char *)NULL, buffersize);
 	if (ret == NULL)
 		goto cleanup;
 	bytesread = 0;
@@ -557,14 +557,14 @@
 		}
 		if (bytesrequested < 0) {
 			buffersize = Util_NewBufferSize(buffersize);
-			if (_PyBytes_Resize(&ret, buffersize) < 0)
+			if (_PyString_Resize(&ret, buffersize) < 0)
 				goto cleanup;
 		} else {
 			break;
 		}
 	}
 	if (bytesread != buffersize)
-		_PyBytes_Resize(&ret, bytesread);
+		_PyString_Resize(&ret, bytesread);
 
 cleanup:
 	RELEASE_LOCK(self);
@@ -594,7 +594,7 @@
 		case MODE_READ:
 			break;
 		case MODE_READ_EOF:
-			ret = PyBytes_FromString("");
+			ret = PyString_FromString("");
 			goto cleanup;
 		case MODE_CLOSED:
 			PyErr_SetString(PyExc_ValueError,
@@ -607,7 +607,7 @@
 	}
 
 	if (sizehint == 0)
-		ret = PyBytes_FromString("");
+		ret = PyString_FromString("");
 	else
 		ret = Util_GetLine(self, (sizehint < 0) ? 0 : sizehint);
 
@@ -701,17 +701,17 @@
 			}
 			if (big_buffer == NULL) {
 				/* Create the big buffer */
-				big_buffer = PyBytes_FromStringAndSize(
+				big_buffer = PyString_FromStringAndSize(
 					NULL, buffersize);
 				if (big_buffer == NULL)
 					goto error;
-				buffer = PyBytes_AS_STRING(big_buffer);
+				buffer = PyString_AS_STRING(big_buffer);
 				memcpy(buffer, small_buffer, nfilled);
 			}
 			else {
 				/* Grow the big buffer */
-				_PyBytes_Resize(&big_buffer, buffersize);
-				buffer = PyBytes_AS_STRING(big_buffer);
+				_PyString_Resize(&big_buffer, buffersize);
+				buffer = PyString_AS_STRING(big_buffer);
 			}
 			continue;			
 		}
@@ -720,7 +720,7 @@
 		while (p != NULL) {
 			/* Process complete lines */
 			p++;
-			line = PyBytes_FromStringAndSize(q, p-q);
+			line = PyString_FromStringAndSize(q, p-q);
 			if (line == NULL)
 				goto error;
 			err = PyList_Append(list, line);
@@ -743,7 +743,7 @@
 	}
 	if (nfilled != 0) {
 		/* Partial last line */
-		line = PyBytes_FromStringAndSize(buffer, nfilled);
+		line = PyString_FromStringAndSize(buffer, nfilled);
 		if (line == NULL)
 			goto error;
 		if (sizehint > 0) {
@@ -753,7 +753,7 @@
 				Py_DECREF(line);
 				goto error;
 			}
-			PyBytes_Concat(&line, rest);
+			PyString_Concat(&line, rest);
 			Py_DECREF(rest);
 			if (line == NULL)
 				goto error;
@@ -915,7 +915,7 @@
 		   could potentially execute Python code. */
 		for (i = 0; i < j; i++) {
 			PyObject *v = PyList_GET_ITEM(list, i);
-			if (!PyBytes_Check(v)) {
+			if (!PyString_Check(v)) {
 			    	const char *buffer;
 			    	Py_ssize_t len;
 				if (PyObject_AsCharBuffer(v, &buffer, &len)) {
@@ -926,7 +926,7 @@
 							"strings");
 					goto error;
 				}
-				line = PyBytes_FromStringAndSize(buffer,
+				line = PyString_FromStringAndSize(buffer,
 								  len);
 				if (line == NULL)
 					goto error;
@@ -942,9 +942,9 @@
 		Py_BEGIN_ALLOW_THREADS
 		for (i = 0; i < j; i++) {
 		    	line = PyList_GET_ITEM(list, i);
-			len = PyBytes_GET_SIZE(line);
+			len = PyString_GET_SIZE(line);
 			BZ2_bzWrite (&bzerror, self->fp,
-				     PyBytes_AS_STRING(line), len);
+				     PyString_AS_STRING(line), len);
 			if (bzerror != BZ_OK) {
 				Py_BLOCK_THREADS
 				Util_CatchBZ2Error(bzerror);
@@ -1224,13 +1224,13 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	case NEWLINE_CR:
-		return PyBytes_FromString("\r");
+		return PyString_FromString("\r");
 	case NEWLINE_LF:
-		return PyBytes_FromString("\n");
+		return PyString_FromString("\n");
 	case NEWLINE_CR|NEWLINE_LF:
 		return Py_BuildValue("(ss)", "\r", "\n");
 	case NEWLINE_CRLF:
-		return PyBytes_FromString("\r\n");
+		return PyString_FromString("\r\n");
 	case NEWLINE_CR|NEWLINE_CRLF:
 		return Py_BuildValue("(ss)", "\r", "\r\n");
 	case NEWLINE_LF|NEWLINE_CRLF:
@@ -1448,7 +1448,7 @@
 static PyObject *
 BZ2File_iternext(BZ2FileObject *self)
 {
-	PyBytesObject* ret;
+	PyStringObject* ret;
 	ACQUIRE_LOCK(self);
 	if (self->mode == MODE_CLOSED) {
 		PyErr_SetString(PyExc_ValueError,
@@ -1457,7 +1457,7 @@
 	}
 	ret = Util_ReadAheadGetLineSkip(self, 0, READAHEAD_BUFSIZE);
 	RELEASE_LOCK(self);
-	if (ret == NULL || PyBytes_GET_SIZE(ret) == 0) {
+	if (ret == NULL || PyString_GET_SIZE(ret) == 0) {
 		Py_XDECREF(ret);
 		return NULL;
 	}
@@ -1559,7 +1559,7 @@
 		return NULL;
 
 	if (datasize == 0)
-		return PyBytes_FromString("");
+		return PyString_FromString("");
 
 	ACQUIRE_LOCK(self);
 	if (!self->running) {
@@ -1568,7 +1568,7 @@
 		goto error;
 	}
 
-	ret = PyBytes_FromStringAndSize(NULL, bufsize);
+	ret = PyString_FromStringAndSize(NULL, bufsize);
 	if (!ret)
 		goto error;
 
@@ -1591,7 +1591,7 @@
 			break; /* no more input data */
 		if (bzs->avail_out == 0) {
 			bufsize = Util_NewBufferSize(bufsize);
-			if (_PyBytes_Resize(&ret, bufsize) < 0) {
+			if (_PyString_Resize(&ret, bufsize) < 0) {
 				BZ2_bzCompressEnd(bzs);
 				goto error;
 			}
@@ -1601,7 +1601,7 @@
 		}
 	}
 
-	_PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+	_PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
 
 	RELEASE_LOCK(self);
 	return ret;
@@ -1636,7 +1636,7 @@
 	}
 	self->running = 0;
 
-	ret = PyBytes_FromStringAndSize(NULL, bufsize);
+	ret = PyString_FromStringAndSize(NULL, bufsize);
 	if (!ret)
 		goto error;
 
@@ -1657,7 +1657,7 @@
 		}
 		if (bzs->avail_out == 0) {
 			bufsize = Util_NewBufferSize(bufsize);
-			if (_PyBytes_Resize(&ret, bufsize) < 0)
+			if (_PyString_Resize(&ret, bufsize) < 0)
 				goto error;
 			bzs->next_out = BUF(ret);
 			bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
@@ -1667,7 +1667,7 @@
 	}
 
 	if (bzs->avail_out != 0)
-		_PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+		_PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
 
 	RELEASE_LOCK(self);
 	return ret;
@@ -1849,7 +1849,7 @@
 		goto error;
 	}
 
-	ret = PyBytes_FromStringAndSize(NULL, bufsize);
+	ret = PyString_FromStringAndSize(NULL, bufsize);
 	if (!ret)
 		goto error;
 
@@ -1868,7 +1868,7 @@
 			if (bzs->avail_in != 0) {
 				Py_DECREF(self->unused_data);
 				self->unused_data =
-				    PyBytes_FromStringAndSize(bzs->next_in,
+				    PyString_FromStringAndSize(bzs->next_in,
 							       bzs->avail_in);
 			}
 			self->running = 0;
@@ -1882,7 +1882,7 @@
 			break; /* no more input data */
 		if (bzs->avail_out == 0) {
 			bufsize = Util_NewBufferSize(bufsize);
-			if (_PyBytes_Resize(&ret, bufsize) < 0) {
+			if (_PyString_Resize(&ret, bufsize) < 0) {
 				BZ2_bzDecompressEnd(bzs);
 				goto error;
 			}
@@ -1894,7 +1894,7 @@
 	}
 
 	if (bzs->avail_out != 0)
-		_PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+		_PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
 
 	RELEASE_LOCK(self);
 	return ret;
@@ -1930,7 +1930,7 @@
 	}
 #endif
 
-	self->unused_data = PyBytes_FromString("");
+	self->unused_data = PyString_FromString("");
 	if (!self->unused_data)
 		goto error;
 
@@ -2063,7 +2063,7 @@
 	 * data in one shot. We will check it later anyway. */
 	bufsize = datasize + (datasize/100+1) + 600;
 
-	ret = PyBytes_FromStringAndSize(NULL, bufsize);
+	ret = PyString_FromStringAndSize(NULL, bufsize);
 	if (!ret)
 		return NULL;
 
@@ -2095,7 +2095,7 @@
 		}
 		if (bzs->avail_out == 0) {
 			bufsize = Util_NewBufferSize(bufsize);
-			if (_PyBytes_Resize(&ret, bufsize) < 0) {
+			if (_PyString_Resize(&ret, bufsize) < 0) {
 				BZ2_bzCompressEnd(bzs);
 				Py_DECREF(ret);
 				return NULL;
@@ -2106,7 +2106,7 @@
 	}
 
 	if (bzs->avail_out != 0)
-		_PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
+		_PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
 	BZ2_bzCompressEnd(bzs);
 
 	return ret;
@@ -2134,9 +2134,9 @@
 		return NULL;
 
 	if (datasize == 0)
-		return PyBytes_FromString("");
+		return PyString_FromString("");
 
-	ret = PyBytes_FromStringAndSize(NULL, bufsize);
+	ret = PyString_FromStringAndSize(NULL, bufsize);
 	if (!ret)
 		return NULL;
 
@@ -2175,7 +2175,7 @@
 		}
 		if (bzs->avail_out == 0) {
 			bufsize = Util_NewBufferSize(bufsize);
-			if (_PyBytes_Resize(&ret, bufsize) < 0) {
+			if (_PyString_Resize(&ret, bufsize) < 0) {
 				BZ2_bzDecompressEnd(bzs);
 				Py_DECREF(ret);
 				return NULL;
@@ -2186,7 +2186,7 @@
 	}
 
 	if (bzs->avail_out != 0)
-		_PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
+		_PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
 	BZ2_bzDecompressEnd(bzs);
 
 	return ret;
@@ -2223,7 +2223,7 @@
 	if (m == NULL)
 		return;
 
-	PyModule_AddObject(m, "__author__", PyBytes_FromString(__author__));
+	PyModule_AddObject(m, "__author__", PyString_FromString(__author__));
 
 	Py_INCREF(&BZ2File_Type);
 	PyModule_AddObject(m, "BZ2File", (PyObject *)&BZ2File_Type);
diff --git a/Modules/cPickle.c b/Modules/cPickle.c
index 4413272..f130087 100644
--- a/Modules/cPickle.c
+++ b/Modules/cPickle.c
@@ -393,13 +393,13 @@
 	if (format) args = Py_VaBuildValue(format, va);
 	va_end(va);
 	if (format && ! args) return NULL;
-	if (stringformat && !(retval=PyBytes_FromString(stringformat)))
+	if (stringformat && !(retval=PyString_FromString(stringformat)))
 		return NULL;
 
 	if (retval) {
 		if (args) {
 			PyObject *v;
-			v=PyBytes_Format(retval, args);
+			v=PyString_Format(retval, args);
 			Py_DECREF(retval);
 			Py_DECREF(args);
 			if (! v) return NULL;
@@ -477,7 +477,7 @@
 	n = (int)_n;
 	if (s == NULL) {
 		if (!( self->buf_size ))  return 0;
-		py_str = PyBytes_FromStringAndSize(self->write_buf,
+		py_str = PyString_FromStringAndSize(self->write_buf,
 						    self->buf_size);
 		if (!py_str)
 			return -1;
@@ -490,7 +490,7 @@
 
 		if (n > WRITE_BUF_SIZE) {
 			if (!( py_str =
-			       PyBytes_FromStringAndSize(s, n)))
+			       PyString_FromStringAndSize(s, n)))
 				return -1;
 		}
 		else {
@@ -655,7 +655,7 @@
 	Py_XDECREF(self->last_string);
 	self->last_string = str;
 
-	if (! (*s = PyBytes_AsString(str))) return -1;
+	if (! (*s = PyString_AsString(str))) return -1;
 	return n;
 }
 
@@ -670,13 +670,13 @@
 		return -1;
 	}
 
-	if ((str_size = PyBytes_Size(str)) < 0)
+	if ((str_size = PyString_Size(str)) < 0)
 		return -1;
 
 	Py_XDECREF(self->last_string);
 	self->last_string = str;
 
-	if (! (*s = PyBytes_AsString(str)))
+	if (! (*s = PyString_AsString(str)))
 		return -1;
 
 	return str_size;
@@ -1078,9 +1078,9 @@
 				"to pickle");
 			goto finally;
 		}
-		repr = PyBytes_FromStringAndSize(NULL, (int)nbytes);
+		repr = PyString_FromStringAndSize(NULL, (int)nbytes);
 		if (repr == NULL) goto finally;
-		pdata = (unsigned char *)PyBytes_AS_STRING(repr);
+		pdata = (unsigned char *)PyString_AS_STRING(repr);
 		i = _PyLong_AsByteArray((PyLongObject *)args,
 	 			pdata, nbytes,
 				1 /* little endian */, 1 /* signed */);
@@ -1121,14 +1121,14 @@
 	if (!( repr = PyObject_Repr(args)))
 		goto finally;
 
-	if ((size = PyBytes_Size(repr)) < 0)
+	if ((size = PyString_Size(repr)) < 0)
 		goto finally;
 
 	if (self->write_func(self, &l, 1) < 0)
 		goto finally;
 
 	if (self->write_func(self,
-			     PyBytes_AS_STRING((PyBytesObject *)repr),
+			     PyString_AS_STRING((PyStringObject *)repr),
 			     			size) < 0)
 		goto finally;
 
@@ -1177,7 +1177,7 @@
 	int size, len;
 	PyObject *repr=0;
 
-	if ((size = PyBytes_Size(args)) < 0)
+	if ((size = PyString_Size(args)) < 0)
 		return -1;
 
 	if (!self->bin) {
@@ -1188,9 +1188,9 @@
 		if (!( repr = PyObject_Repr(args)))
 			return -1;
 
-		if ((len = PyBytes_Size(repr)) < 0)
+		if ((len = PyString_Size(repr)) < 0)
 			goto err;
-		repr_str = PyBytes_AS_STRING((PyBytesObject *)repr);
+		repr_str = PyString_AS_STRING((PyStringObject *)repr);
 
 		if (self->write_func(self, &string, 1) < 0)
 			goto err;
@@ -1207,7 +1207,7 @@
 		int i;
 		char c_str[5];
 
-		if ((size = PyBytes_Size(args)) < 0)
+		if ((size = PyString_Size(args)) < 0)
 			return -1;
 
 		if (size < 256) {
@@ -1233,8 +1233,8 @@
 		}
 		else {
 			if (self->write_func(self,
-					     PyBytes_AS_STRING(
-					     	(PyBytesObject *)args),
+					     PyString_AS_STRING(
+					     	(PyStringObject *)args),
 					     size) < 0)
 				return -1;
 		}
@@ -1264,13 +1264,13 @@
 
 	static const char *hexdigit = "0123456789ABCDEF";
 
-	repr = PyBytes_FromStringAndSize(NULL, 6 * size);
+	repr = PyString_FromStringAndSize(NULL, 6 * size);
 	if (repr == NULL)
 		return NULL;
 	if (size == 0)
 		return repr;
 
-	p = q = PyBytes_AS_STRING(repr);
+	p = q = PyString_AS_STRING(repr);
 	while (size-- > 0) {
 		Py_UNICODE ch = *s++;
 		/* Map 16-bit characters to '\uxxxx' */
@@ -1287,7 +1287,7 @@
 			*p++ = (char) ch;
 	}
 	*p = '\0';
-	_PyBytes_Resize(&repr, p - q);
+	_PyString_Resize(&repr, p - q);
 	return repr;
 }
 
@@ -1310,9 +1310,9 @@
 		if (!repr)
 			return -1;
 
-		if ((len = PyBytes_Size(repr)) < 0)
+		if ((len = PyString_Size(repr)) < 0)
 			goto err;
-		repr_str = PyBytes_AS_STRING((PyBytesObject *)repr);
+		repr_str = PyString_AS_STRING((PyStringObject *)repr);
 
 		if (self->write_func(self, &string, 1) < 0)
 			goto err;
@@ -1332,7 +1332,7 @@
 		if (!( repr = PyUnicode_AsUTF8String(args)))
 			return -1;
 
-		if ((size = PyBytes_Size(repr)) < 0)
+		if ((size = PyString_Size(repr)) < 0)
 			goto err;
 		if (size > INT_MAX)
 			return -1;   /* string too large */
@@ -1351,7 +1351,7 @@
 			PDATA_APPEND(self->file, repr, -1);
 		}
 		else {
-			if (self->write_func(self, PyBytes_AS_STRING(repr),
+			if (self->write_func(self, PyString_AS_STRING(repr),
 					     size) < 0)
 				goto err;
 		}
@@ -1861,12 +1861,12 @@
 			goto finally;
 
 
-		if ((module_size = PyBytes_Size(module)) < 0 ||
-		    (name_size = PyBytes_Size(name)) < 0)
+		if ((module_size = PyString_Size(module)) < 0 ||
+		    (name_size = PyString_Size(name)) < 0)
 			goto finally;
 
-		module_str = PyBytes_AS_STRING((PyBytesObject *)module);
-		name_str   = PyBytes_AS_STRING((PyBytesObject *)name);
+		module_str = PyString_AS_STRING((PyStringObject *)module);
+		name_str   = PyString_AS_STRING((PyStringObject *)name);
 
 		if (self->write_func(self, &inst, 1) < 0)
 			goto finally;
@@ -1961,12 +1961,12 @@
 	if (!( module = whichmodule(args, global_name)))
 		goto finally;
 
-	if ((module_size = PyBytes_Size(module)) < 0 ||
-	    (name_size = PyBytes_Size(global_name)) < 0)
+	if ((module_size = PyString_Size(module)) < 0 ||
+	    (name_size = PyString_Size(global_name)) < 0)
 		goto finally;
 
-	module_str = PyBytes_AS_STRING((PyBytesObject *)module);
-	name_str   = PyBytes_AS_STRING((PyBytesObject *)global_name);
+	module_str = PyString_AS_STRING((PyStringObject *)module);
+	name_str   = PyString_AS_STRING((PyStringObject *)global_name);
 
 	/* XXX This can be doing a relative import.  Clearly it shouldn't,
 	   but I don't know how to stop it. :-( */
@@ -2099,7 +2099,7 @@
 
 	if (pid != Py_None) {
 		if (!self->bin) {
-			if (!PyBytes_Check(pid)) {
+			if (!PyString_Check(pid)) {
 				PyErr_SetString(PicklingError,
 						"persistent id must be string");
 				goto finally;
@@ -2108,12 +2108,12 @@
 			if (self->write_func(self, &persid, 1) < 0)
 				goto finally;
 
-			if ((size = PyBytes_Size(pid)) < 0)
+			if ((size = PyString_Size(pid)) < 0)
 				goto finally;
 
 			if (self->write_func(self,
-					     PyBytes_AS_STRING(
-					     	(PyBytesObject *)pid),
+					     PyString_AS_STRING(
+					     	(PyStringObject *)pid),
 					     size) < 0)
 				goto finally;
 
@@ -2194,8 +2194,8 @@
 			use_newobj = 0;
 		}
 		else {
-			use_newobj = PyBytes_Check(temp) &&
-				     strcmp(PyBytes_AS_STRING(temp),
+			use_newobj = PyString_Check(temp) &&
+				     strcmp(PyString_AS_STRING(temp),
 				     	    "__newobj__") == 0;
 			Py_DECREF(temp);
 		}
@@ -2362,14 +2362,14 @@
 		break;
 
         case 's':
-		if ((type == &PyBytes_Type) && (PyBytes_GET_SIZE(args) < 2)) {
+		if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
 			res = save_string(self, args, 0);
 			goto finally;
 		}
 
 #ifdef Py_USING_UNICODE
         case 'u':
-		if ((type == &PyUnicode_Type) && (PyBytes_GET_SIZE(args) < 2)) {
+		if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {
 			res = save_unicode(self, args, 0);
 			goto finally;
 		}
@@ -2391,7 +2391,7 @@
 
 	switch (type->tp_name[0]) {
         case 's':
-		if (type == &PyBytes_Type) {
+		if (type == &PyString_Type) {
 			res = save_string(self, args, 1);
 			goto finally;
 		}
@@ -2526,7 +2526,7 @@
 	if (t == NULL)
 		goto finally;
 
-	if (PyBytes_Check(t)) {
+	if (PyString_Check(t)) {
 		res = save_global(self, args, t);
 		goto finally;
 	}
@@ -2640,8 +2640,8 @@
 	for (rsize = 0, i = l; --i >= 0; ) {
 		k = data->data[i];
 
-		if (PyBytes_Check(k))
-			rsize += PyBytes_GET_SIZE(k);
+		if (PyString_Check(k))
+			rsize += PyString_GET_SIZE(k);
 
 		else if (PyInt_Check(k)) { /* put */
 			ik = PyInt_AS_LONG((PyIntObject*)k);
@@ -2676,17 +2676,17 @@
 	}
 
 	/* Now generate the result */
-	r = PyBytes_FromStringAndSize(NULL, rsize);
+	r = PyString_FromStringAndSize(NULL, rsize);
 	if (r == NULL) goto err;
-	s = PyBytes_AS_STRING((PyBytesObject *)r);
+	s = PyString_AS_STRING((PyStringObject *)r);
 
 	for (i = 0; i < l; i++) {
 		k = data->data[i];
 
-		if (PyBytes_Check(k)) {
-			ssize = PyBytes_GET_SIZE(k);
+		if (PyString_Check(k)) {
+			ssize = PyString_GET_SIZE(k);
 			if (ssize) {
-				p=PyBytes_AS_STRING((PyBytesObject *)k);
+				p=PyString_AS_STRING((PyStringObject *)k);
 				while (--ssize >= 0)
 					*s++ = *p++;
 			}
@@ -3410,7 +3410,7 @@
 		goto insecure;
 	/********************************************/
 
-	str = PyBytes_DecodeEscape(p, len, NULL, 0, NULL);
+	str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
 	free(s);
 	if (str) {
 		PDATA_PUSH(self->stack, str, -1);
@@ -3439,7 +3439,7 @@
 	if (self->read_func(self, &s, l) < 0)
 		return -1;
 
-	if (!( py_string = PyBytes_FromStringAndSize(s, l)))
+	if (!( py_string = PyString_FromStringAndSize(s, l)))
 		return -1;
 
 	PDATA_PUSH(self->stack, py_string, -1);
@@ -3461,7 +3461,7 @@
 
 	if (self->read_func(self, &s, l) < 0) return -1;
 
-	if (!( py_string = PyBytes_FromStringAndSize(s, l)))  return -1;
+	if (!( py_string = PyString_FromStringAndSize(s, l)))  return -1;
 
 	PDATA_PUSH(self->stack, py_string, -1);
 	return 0;
@@ -3688,12 +3688,12 @@
 
 	if ((len = self->readline_func(self, &s)) < 0) return -1;
 	if (len < 2) return bad_readline();
-	module_name = PyBytes_FromStringAndSize(s, len - 1);
+	module_name = PyString_FromStringAndSize(s, len - 1);
 	if (!module_name)  return -1;
 
 	if ((len = self->readline_func(self, &s)) >= 0) {
 		if (len < 2) return bad_readline();
-		if ((class_name = PyBytes_FromStringAndSize(s, len - 1))) {
+		if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
 			class = find_class(module_name, class_name,
 					   self->find_class);
 			Py_DECREF(class_name);
@@ -3772,7 +3772,7 @@
 
 	if ((len = self->readline_func(self, &s)) < 0) return -1;
 	if (len < 2) return bad_readline();
-	module_name = PyBytes_FromStringAndSize(s, len - 1);
+	module_name = PyString_FromStringAndSize(s, len - 1);
 	if (!module_name)  return -1;
 
 	if ((len = self->readline_func(self, &s)) >= 0) {
@@ -3780,7 +3780,7 @@
 			Py_DECREF(module_name);
 			return bad_readline();
 		}
-		if ((class_name = PyBytes_FromStringAndSize(s, len - 1))) {
+		if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
 			class = find_class(module_name, class_name,
 					   self->find_class);
 			Py_DECREF(class_name);
@@ -3805,7 +3805,7 @@
 		if ((len = self->readline_func(self, &s)) < 0) return -1;
 		if (len < 2) return bad_readline();
 
-		pid = PyBytes_FromStringAndSize(s, len - 1);
+		pid = PyString_FromStringAndSize(s, len - 1);
 		if (!pid)  return -1;
 
 		if (PyList_Check(self->pers_func)) {
@@ -3938,7 +3938,7 @@
 	if ((len = self->readline_func(self, &s)) < 0) return -1;
 	if (len < 2) return bad_readline();
 
-	if (!( py_str = PyBytes_FromStringAndSize(s, len - 1)))  return -1;
+	if (!( py_str = PyString_FromStringAndSize(s, len - 1)))  return -1;
 
 	value = PyDict_GetItem(self->memo, py_str);
 	if (! value) {
@@ -4064,8 +4064,8 @@
 	 * confirm that pair is really a 2-tuple of strings.
 	 */
 	if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
-	    !PyBytes_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
-	    !PyBytes_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
+	    !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
+	    !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
 		Py_DECREF(py_code);
 		PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
 			     "isn't a 2-tuple of strings", code);
@@ -4098,7 +4098,7 @@
 	if ((l = self->readline_func(self, &s)) < 0) return -1;
 	if (l < 2) return bad_readline();
 	if (!( len=self->stack->length ))  return stackUnderflow();
-	if (!( py_str = PyBytes_FromStringAndSize(s, l - 1)))  return -1;
+	if (!( py_str = PyString_FromStringAndSize(s, l - 1)))  return -1;
 	value=self->stack->data[len-1];
 	l=PyDict_SetItem(self->memo, py_str, value);
 	Py_DECREF(py_str);
@@ -5568,7 +5568,7 @@
 {
 	PyObject *copyreg, *t, *r;
 
-#define INIT_STR(S) if (!( S ## _str=PyBytes_InternFromString(#S)))  return -1;
+#define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S)))  return -1;
 
 	if (PyType_Ready(&Unpicklertype) < 0)
 		return -1;
@@ -5736,7 +5736,7 @@
 
 	/* Add some symbolic constants to the module */
 	d = PyModule_GetDict(m);
-	v = PyBytes_FromString(rev);
+	v = PyString_FromString(rev);
 	PyDict_SetItemString(d, "__version__", v);
 	Py_XDECREF(v);
 
@@ -5755,7 +5755,7 @@
 
 	/* These are purely informational; no code uses them. */
 	/* File format version we write. */
-	format_version = PyBytes_FromString("2.0");
+	format_version = PyString_FromString("2.0");
 	/* Format versions we can read. */
 	compatible_formats = Py_BuildValue("[sssss]",
 		"1.0",	/* Original protocol 0 */
diff --git a/Modules/cStringIO.c b/Modules/cStringIO.c
index 576a176..139a4a8 100644
--- a/Modules/cStringIO.c
+++ b/Modules/cStringIO.c
@@ -119,7 +119,7 @@
 static PyObject *
 IO_cgetval(PyObject *self) {
         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
-        return PyBytes_FromStringAndSize(((IOobject*)self)->buf,
+        return PyString_FromStringAndSize(((IOobject*)self)->buf,
                                           ((IOobject*)self)->pos);
 }
 
@@ -137,7 +137,7 @@
         }
         else
                   s=self->string_size;
-        return PyBytes_FromStringAndSize(self->buf, s);
+        return PyString_FromStringAndSize(self->buf, s);
 }
 
 PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
@@ -177,7 +177,7 @@
 
         if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
 
-        return PyBytes_FromStringAndSize(output, n);
+        return PyString_FromStringAndSize(output, n);
 }
 
 PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
@@ -215,7 +215,7 @@
                 n -= m;
                 self->pos -= m;
         }
-        return PyBytes_FromStringAndSize(output, n);
+        return PyString_FromStringAndSize(output, n);
 }
 
 PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
@@ -238,7 +238,7 @@
                         goto err;
 		if (n == 0)
 			break;
-		line = PyBytes_FromStringAndSize (output, n);
+		line = PyString_FromStringAndSize (output, n);
 		if (!line) 
                         goto err;
 		if (PyList_Append (result, line) == -1) {
@@ -315,7 +315,7 @@
 	next = IO_readline((IOobject *)self, NULL);
 	if (!next)
 		return NULL;
-	if (!PyBytes_GET_SIZE(next)) {
+	if (!PyString_GET_SIZE(next)) {
 		Py_DECREF(next);
 		PyErr_SetNone(PyExc_StopIteration);
 		return NULL;
@@ -456,7 +456,7 @@
 	while ((s = PyIter_Next(it)) != NULL) {
 		Py_ssize_t n;
 		char *c;
-		if (PyBytes_AsStringAndSize(s, &c, &n) == -1) {
+		if (PyString_AsStringAndSize(s, &c, &n) == -1) {
 			Py_DECREF(it);
 			Py_DECREF(s);
 			return NULL;
diff --git a/Modules/cdmodule.c b/Modules/cdmodule.c
index 8602d5d..f09b0a4 100644
--- a/Modules/cdmodule.c
+++ b/Modules/cdmodule.c
@@ -239,19 +239,19 @@
 	if (!PyArg_ParseTuple(args, "i:readda", &numframes))
 		return NULL;
 
-	result = PyBytes_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
+	result = PyString_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
 	if (result == NULL)
 		return NULL;
 
 	n = CDreadda(self->ob_cdplayer,
-		       (CDFRAME *) PyBytes_AsString(result), numframes);
+		       (CDFRAME *) PyString_AsString(result), numframes);
 	if (n == -1) {
 		Py_DECREF(result);
 		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 	if (n < numframes)
-		_PyBytes_Resize(&result, n * sizeof(CDFRAME));
+		_PyString_Resize(&result, n * sizeof(CDFRAME));
 
 	return result;
 }
@@ -468,7 +468,7 @@
 	PyTuple_SetItem(args, 1, PyInt_FromLong((long) type));
 	switch (type) {
 	case cd_audio:
-		v = PyBytes_FromStringAndSize(data, CDDA_DATASIZE);
+		v = PyString_FromStringAndSize(data, CDDA_DATASIZE);
 		break;
 	case cd_pnum:
 	case cd_index:
@@ -484,15 +484,15 @@
 #undef ptr
 		break;
 	case cd_catalog:
-		v = PyBytes_FromStringAndSize(NULL, 13);
-		p = PyBytes_AsString(v);
+		v = PyString_FromStringAndSize(NULL, 13);
+		p = PyString_AsString(v);
 		for (i = 0; i < 13; i++)
 			*p++ = ((char *) data)[i] + '0';
 		break;
 	case cd_ident:
 #define ptr ((struct cdident *) data)
-		v = PyBytes_FromStringAndSize(NULL, 12);
-		p = PyBytes_AsString(v);
+		v = PyString_FromStringAndSize(NULL, 12);
+		p = PyString_AsString(v);
 		CDsbtoa(p, ptr->country, 2);
 		p += 2;
 		CDsbtoa(p, ptr->owner, 3);
diff --git a/Modules/cgensupport.c b/Modules/cgensupport.c
index 965f7b4..7e7d0ff 100644
--- a/Modules/cgensupport.c
+++ b/Modules/cgensupport.c
@@ -119,10 +119,10 @@
 	PyObject *v;
 	if (!PyArg_GetObject(args, nargs, i, &v))
 		return 0;
-	if (!PyBytes_Check(v)) {
+	if (!PyString_Check(v)) {
 		return PyErr_BadArgument();
 	}
-	*p_arg = PyBytes_AsString(v);
+	*p_arg = PyString_AsString(v);
 	return 1;
 }
 
diff --git a/Modules/cjkcodecs/cjkcodecs.h b/Modules/cjkcodecs/cjkcodecs.h
index c06319e..4005bcf 100644
--- a/Modules/cjkcodecs/cjkcodecs.h
+++ b/Modules/cjkcodecs/cjkcodecs.h
@@ -261,7 +261,7 @@
 	const MultibyteCodec *codec;
 	const char *enc;
 
-	if (!PyBytes_Check(encoding)) {
+	if (!PyString_Check(encoding)) {
 		PyErr_SetString(PyExc_TypeError,
 				"encoding name must be a string.");
 		return NULL;
@@ -271,7 +271,7 @@
 	if (cofunc == NULL)
 		return NULL;
 
-	enc = PyBytes_AS_STRING(encoding);
+	enc = PyString_AS_STRING(encoding);
 	for (codec = codec_list; codec->encoding[0]; codec++)
 		if (strcmp(codec->encoding, enc) == 0)
 			break;
diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index e70ec53..bbd4c1a 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -85,7 +85,7 @@
 	else if (strcmp(errors, "replace") == 0)
 		return ERROR_REPLACE;
 	else
-		return PyBytes_FromString(errors);
+		return PyString_FromString(errors);
 }
 
 static PyObject *
@@ -93,8 +93,8 @@
 {
 	PyObject *args, *cb, *r;
 
-	assert(PyBytes_Check(errors));
-	cb = PyCodec_LookupError(PyBytes_AS_STRING(errors));
+	assert(PyString_Check(errors));
+	cb = PyCodec_LookupError(PyString_AS_STRING(errors));
 	if (cb == NULL)
 		return NULL;
 
@@ -129,7 +129,7 @@
 		return self->errors;
 	}
 
-	return PyBytes_FromString(errors);
+	return PyString_FromString(errors);
 }
 
 static int
@@ -138,12 +138,12 @@
 {
 	PyObject *cb;
 
-	if (!PyBytes_Check(value)) {
+	if (!PyString_Check(value)) {
 		PyErr_SetString(PyExc_TypeError, "errors must be a string");
 		return -1;
 	}
 
-	cb = internal_error_callback(PyBytes_AS_STRING(value));
+	cb = internal_error_callback(PyString_AS_STRING(value));
 	if (cb == NULL)
 		return -1;
 
@@ -166,15 +166,15 @@
 	Py_ssize_t orgpos, orgsize;
 
 	orgpos = (Py_ssize_t)((char *)buf->outbuf -
-				PyBytes_AS_STRING(buf->outobj));
-	orgsize = PyBytes_GET_SIZE(buf->outobj);
-	if (_PyBytes_Resize(&buf->outobj, orgsize + (
+				PyString_AS_STRING(buf->outobj));
+	orgsize = PyString_GET_SIZE(buf->outobj);
+	if (_PyString_Resize(&buf->outobj, orgsize + (
 	    esize < (orgsize >> 1) ? (orgsize >> 1) | 1 : esize)) == -1)
 		return -1;
 
-	buf->outbuf = (unsigned char *)PyBytes_AS_STRING(buf->outobj) +orgpos;
-	buf->outbuf_end = (unsigned char *)PyBytes_AS_STRING(buf->outobj)
-		+ PyBytes_GET_SIZE(buf->outobj);
+	buf->outbuf = (unsigned char *)PyString_AS_STRING(buf->outobj) +orgpos;
+	buf->outbuf_end = (unsigned char *)PyString_AS_STRING(buf->outobj)
+		+ PyString_GET_SIZE(buf->outobj);
 
 	return 0;
 }
@@ -322,10 +322,10 @@
 			goto errorexit;
 	}
 
-	retstrsize = PyBytes_GET_SIZE(retstr);
+	retstrsize = PyString_GET_SIZE(retstr);
 	REQUIRE_ENCODEBUFFER(buf, retstrsize);
 
-	memcpy(buf->outbuf, PyBytes_AS_STRING(retstr), retstrsize);
+	memcpy(buf->outbuf, PyString_AS_STRING(retstr), retstrsize);
 	buf->outbuf += retstrsize;
 
 	newpos = PyInt_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
@@ -468,16 +468,16 @@
 	Py_ssize_t finalsize, r = 0;
 
 	if (datalen == 0)
-		return PyBytes_FromString("");
+		return PyString_FromString("");
 
 	buf.excobj = NULL;
 	buf.inbuf = buf.inbuf_top = *data;
 	buf.inbuf_end = buf.inbuf_top + datalen;
-	buf.outobj = PyBytes_FromStringAndSize(NULL, datalen * 2 + 16);
+	buf.outobj = PyString_FromStringAndSize(NULL, datalen * 2 + 16);
 	if (buf.outobj == NULL)
 		goto errorexit;
-	buf.outbuf = (unsigned char *)PyBytes_AS_STRING(buf.outobj);
-	buf.outbuf_end = buf.outbuf + PyBytes_GET_SIZE(buf.outobj);
+	buf.outbuf = (unsigned char *)PyString_AS_STRING(buf.outobj);
+	buf.outbuf_end = buf.outbuf + PyString_GET_SIZE(buf.outobj);
 
 	while (buf.inbuf < buf.inbuf_end) {
 		Py_ssize_t inleft, outleft;
@@ -512,10 +512,10 @@
 		}
 
 	finalsize = (Py_ssize_t)((char *)buf.outbuf -
-				 PyBytes_AS_STRING(buf.outobj));
+				 PyString_AS_STRING(buf.outobj));
 
-	if (finalsize != PyBytes_GET_SIZE(buf.outobj))
-		if (_PyBytes_Resize(&buf.outobj, finalsize) == -1)
+	if (finalsize != PyString_GET_SIZE(buf.outobj))
+		if (_PyString_Resize(&buf.outobj, finalsize) == -1)
 			goto errorexit;
 
 	Py_XDECREF(buf.excobj);
@@ -1222,35 +1222,35 @@
 		if (cres == NULL)
 			goto errorexit;
 
-		if (!PyBytes_Check(cres)) {
+		if (!PyString_Check(cres)) {
 			PyErr_SetString(PyExc_TypeError,
 					"stream function returned a "
 					"non-string object");
 			goto errorexit;
 		}
 
-		endoffile = (PyBytes_GET_SIZE(cres) == 0);
+		endoffile = (PyString_GET_SIZE(cres) == 0);
 
 		if (self->pendingsize > 0) {
 			PyObject *ctr;
 			char *ctrdata;
 
-			rsize = PyBytes_GET_SIZE(cres) + self->pendingsize;
-			ctr = PyBytes_FromStringAndSize(NULL, rsize);
+			rsize = PyString_GET_SIZE(cres) + self->pendingsize;
+			ctr = PyString_FromStringAndSize(NULL, rsize);
 			if (ctr == NULL)
 				goto errorexit;
-			ctrdata = PyBytes_AS_STRING(ctr);
+			ctrdata = PyString_AS_STRING(ctr);
 			memcpy(ctrdata, self->pending, self->pendingsize);
 			memcpy(ctrdata + self->pendingsize,
-				PyBytes_AS_STRING(cres),
-				PyBytes_GET_SIZE(cres));
+				PyString_AS_STRING(cres),
+				PyString_GET_SIZE(cres));
 			Py_DECREF(cres);
 			cres = ctr;
 			self->pendingsize = 0;
 		}
 
-		rsize = PyBytes_GET_SIZE(cres);
-		if (decoder_prepare_buffer(&buf, PyBytes_AS_STRING(cres),
+		rsize = PyString_GET_SIZE(cres);
+		if (decoder_prepare_buffer(&buf, PyString_AS_STRING(cres),
 					   rsize) != 0)
 			goto errorexit;
 
@@ -1585,7 +1585,7 @@
 	if (pwrt == NULL)
 		return NULL;
 
-	if (PyBytes_Size(pwrt) > 0) {
+	if (PyString_Size(pwrt) > 0) {
 		PyObject *wr;
 		wr = PyObject_CallMethod(self->stream, "write", "O", pwrt);
 		if (wr == NULL) {
diff --git a/Modules/clmodule.c b/Modules/clmodule.c
index b504eed..d3e0edf 100644
--- a/Modules/clmodule.c
+++ b/Modules/clmodule.c
@@ -111,7 +111,7 @@
 		return NULL;
 
   retry:
-	compressedBuffer = PyBytes_FromStringAndSize(NULL, frameBufferSize);
+	compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
 	if (compressedBuffer == NULL)
 		return NULL;
 
@@ -120,7 +120,7 @@
 	if (clCompressImage(compressionScheme, width, height, originalFormat,
 			    compressionRatio, (void *) frameBuffer,
 			    &compressedBufferSize,
-			    (void *) PyBytes_AsString(compressedBuffer))
+			    (void *) PyString_AsString(compressedBuffer))
 	    == FAILURE || error_handler_called) {
 		Py_DECREF(compressedBuffer);
 		if (!error_handler_called)
@@ -135,7 +135,7 @@
 	}
 
 	if (compressedBufferSize < frameBufferSize)
-		_PyBytes_Resize(&compressedBuffer, compressedBufferSize);
+		_PyString_Resize(&compressedBuffer, compressedBufferSize);
 
 	return compressedBuffer;
 }
@@ -155,14 +155,14 @@
 
 	frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
 
-	frameBuffer = PyBytes_FromStringAndSize(NULL, frameBufferSize);
+	frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
 	if (frameBuffer == NULL)
 		return NULL;
 
 	error_handler_called = 0;
 	if (clDecompressImage(compressionScheme, width, height, originalFormat,
 			      compressedBufferSize, compressedBuffer,
-			      (void *) PyBytes_AsString(frameBuffer))
+			      (void *) PyString_AsString(frameBuffer))
 	    == FAILURE || error_handler_called) {
 		Py_DECREF(frameBuffer);
 		if (!error_handler_called)
@@ -236,14 +236,14 @@
 	if (error_handler_called)
 		return NULL;
 
-	data = PyBytes_FromStringAndSize(NULL, size);
+	data = PyString_FromStringAndSize(NULL, size);
 	if (data == NULL)
 		return NULL;
 
 	error_handler_called = 0;
 	if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
 		       (void *) frameBuffer, &compressedBufferSize,
-		       (void *) PyBytes_AsString(data)) == FAILURE ||
+		       (void *) PyString_AsString(data)) == FAILURE ||
 	    error_handler_called) {
 		Py_DECREF(data);
 		if (!error_handler_called)
@@ -252,7 +252,7 @@
 	}
 
 	if (compressedBufferSize < size)
-		if (_PyBytes_Resize(&data, compressedBufferSize))
+		if (_PyString_Resize(&data, compressedBufferSize))
 			return NULL;
 
 	if (compressedBufferSize > size) {
@@ -285,14 +285,14 @@
 	if (error_handler_called)
 		return NULL;
 
-	data = PyBytes_FromStringAndSize(NULL, dataSize);
+	data = PyString_FromStringAndSize(NULL, dataSize);
 	if (data == NULL)
 		return NULL;
 
 	error_handler_called = 0;
 	if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
 			 compressedDataSize, (void *) compressedData,
-			 (void *) PyBytes_AsString(data)) == FAILURE ||
+			 (void *) PyString_AsString(data)) == FAILURE ||
 	    error_handler_called) {
 		Py_DECREF(data);
 		if (!error_handler_called)
@@ -514,7 +514,7 @@
 			PyList_SetItem(list, i, Py_None);
 		} else
 			PyList_SetItem(list, i,
-				   PyBytes_FromString((char *) PVbuffer[i]));
+				   PyString_FromString((char *) PVbuffer[i]));
 	}
 
 	PyMem_DEL(PVbuffer);
@@ -563,7 +563,7 @@
 		return NULL;
 	}
 
-	return PyBytes_FromString(name);
+	return PyString_FromString(name);
 }
 
 static PyObject *
@@ -775,7 +775,7 @@
 			PyList_SetItem(list, i, Py_None);
 		} else
 			PyList_SetItem(list, i,
-				   PyBytes_FromString((char *) PVbuffer[i]));
+				   PyString_FromString((char *) PVbuffer[i]));
 	}
 
 	PyMem_DEL(PVbuffer);
@@ -818,7 +818,7 @@
 		return NULL;
 	}
 
-	return PyBytes_FromString(name);
+	return PyString_FromString(name);
 }
 
 static PyObject *
diff --git a/Modules/datetimemodule.c b/Modules/datetimemodule.c
index 49bd656..3adf0e2 100644
--- a/Modules/datetimemodule.c
+++ b/Modules/datetimemodule.c
@@ -947,7 +947,7 @@
 	else
 		result = PyObject_CallMethod(tzinfo, "tzname", "O", tzinfoarg);
 
-	if (result != NULL && result != Py_None && ! PyBytes_Check(result)) {
+	if (result != NULL && result != Py_None && ! PyString_Check(result)) {
 		PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must "
 			     "return None or a string, not '%s'",
 			     Py_TYPE(result)->tp_name);
@@ -1046,27 +1046,27 @@
 {
 	PyObject *temp;
 
-	assert(PyBytes_Check(repr));
+	assert(PyString_Check(repr));
 	assert(tzinfo);
 	if (tzinfo == Py_None)
 		return repr;
 	/* Get rid of the trailing ')'. */
-	assert(PyBytes_AsString(repr)[PyBytes_Size(repr)-1] == ')');
-	temp = PyBytes_FromStringAndSize(PyBytes_AsString(repr),
-					  PyBytes_Size(repr) - 1);
+	assert(PyString_AsString(repr)[PyString_Size(repr)-1] == ')');
+	temp = PyString_FromStringAndSize(PyString_AsString(repr),
+					  PyString_Size(repr) - 1);
 	Py_DECREF(repr);
 	if (temp == NULL)
 		return NULL;
 	repr = temp;
 
 	/* Append ", tzinfo=". */
-	PyBytes_ConcatAndDel(&repr, PyBytes_FromString(", tzinfo="));
+	PyString_ConcatAndDel(&repr, PyString_FromString(", tzinfo="));
 
 	/* Append repr(tzinfo). */
-	PyBytes_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
+	PyString_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
 
 	/* Add a closing paren. */
-	PyBytes_ConcatAndDel(&repr, PyBytes_FromString(")"));
+	PyString_ConcatAndDel(&repr, PyString_FromString(")"));
 	return repr;
 }
 
@@ -1092,7 +1092,7 @@
 		      DayNames[wday], MonthNames[GET_MONTH(date) - 1],
 		      GET_DAY(date), hours, minutes, seconds,
 		      GET_YEAR(date));
-	return PyBytes_FromString(buffer);
+	return PyString_FromString(buffer);
 }
 
 /* Add an hours & minutes UTC offset string to buf.  buf has no more than
@@ -1143,7 +1143,7 @@
 	else
 	    sprintf(freplacement, "%06d", 0);
 
-	return PyBytes_FromStringAndSize(freplacement, strlen(freplacement));
+	return PyString_FromStringAndSize(freplacement, strlen(freplacement));
 }
 
 /* I sure don't want to reproduce the strftime code from the time module,
@@ -1230,7 +1230,7 @@
 				/* format utcoffset */
 				char buf[100];
 				PyObject *tzinfo = get_tzinfo_member(object);
-				zreplacement = PyBytes_FromString("");
+				zreplacement = PyString_FromString("");
 				if (zreplacement == NULL) goto Done;
 				if (tzinfo != Py_None && tzinfo != NULL) {
 					assert(tzinfoarg != NULL);
@@ -1241,19 +1241,19 @@
 							     tzinfoarg) < 0)
 						goto Done;
 					Py_DECREF(zreplacement);
-					zreplacement = PyBytes_FromString(buf);
+					zreplacement = PyString_FromString(buf);
 					if (zreplacement == NULL) goto Done;
 				}
 			}
 			assert(zreplacement != NULL);
-			ptoappend = PyBytes_AS_STRING(zreplacement);
-			ntoappend = PyBytes_GET_SIZE(zreplacement);
+			ptoappend = PyString_AS_STRING(zreplacement);
+			ntoappend = PyString_GET_SIZE(zreplacement);
 		}
 		else if (ch == 'Z') {
 			/* format tzname */
 			if (Zreplacement == NULL) {
 				PyObject *tzinfo = get_tzinfo_member(object);
-				Zreplacement = PyBytes_FromString("");
+				Zreplacement = PyString_FromString("");
 				if (Zreplacement == NULL) goto Done;
 				if (tzinfo != Py_None && tzinfo != NULL) {
 					PyObject *temp;
@@ -1261,7 +1261,7 @@
 					temp = call_tzname(tzinfo, tzinfoarg);
 					if (temp == NULL) goto Done;
 					if (temp != Py_None) {
-						assert(PyBytes_Check(temp));
+						assert(PyString_Check(temp));
 						/* Since the tzname is getting
 						 * stuffed into the format, we
 						 * have to double any % signs
@@ -1275,7 +1275,7 @@
 						Py_DECREF(temp);
 						if (Zreplacement == NULL)
 							goto Done;
-						if (!PyBytes_Check(Zreplacement)) {
+						if (!PyString_Check(Zreplacement)) {
 							PyErr_SetString(PyExc_TypeError, "tzname.replace() did not return a string");
 							goto Done;
 						}
@@ -1285,8 +1285,8 @@
 				}
 			}
 			assert(Zreplacement != NULL);
-			ptoappend = PyBytes_AS_STRING(Zreplacement);
-			ntoappend = PyBytes_GET_SIZE(Zreplacement);
+			ptoappend = PyString_AS_STRING(Zreplacement);
+			ntoappend = PyString_GET_SIZE(Zreplacement);
 		}
 		else if (ch == 'f') {
 			/* format microseconds */
@@ -1296,9 +1296,9 @@
 					goto Done;
 			}
 			assert(freplacement != NULL);
-			assert(PyBytes_Check(freplacement));
-			ptoappend = PyBytes_AS_STRING(freplacement);
-			ntoappend = PyBytes_GET_SIZE(freplacement);
+			assert(PyString_Check(freplacement));
+			ptoappend = PyString_AS_STRING(freplacement);
+			ntoappend = PyString_GET_SIZE(freplacement);
 		}
 		else {
 			/* percent followed by neither z nor Z */
@@ -1319,10 +1319,10 @@
  				PyErr_NoMemory();
  				goto Done;
  			}
- 			if (_PyBytes_Resize(&newfmt, bigger) < 0)
+ 			if (_PyString_Resize(&newfmt, bigger) < 0)
  				goto Done;
  			totalnew = bigger;
- 			pnew = PyBytes_AsString(newfmt) + usednew;
+ 			pnew = PyString_AsString(newfmt) + usednew;
  		}
 		memcpy(pnew, ptoappend, ntoappend);
 		pnew += ntoappend;
@@ -1330,7 +1330,7 @@
 		assert(usednew <= totalnew);
 	}  /* end while() */
 
-	if (_PyBytes_Resize(&newfmt, usednew) < 0)
+	if (_PyString_Resize(&newfmt, usednew) < 0)
 		goto Done;
 	{
 		PyObject *time = PyImport_ImportModuleNoBlock("time");
@@ -2008,18 +2008,18 @@
 delta_repr(PyDateTime_Delta *self)
 {
 	if (GET_TD_MICROSECONDS(self) != 0)
-		return PyBytes_FromFormat("%s(%d, %d, %d)",
+		return PyString_FromFormat("%s(%d, %d, %d)",
 					   Py_TYPE(self)->tp_name,
 					   GET_TD_DAYS(self),
 					   GET_TD_SECONDS(self),
 					   GET_TD_MICROSECONDS(self));
 	if (GET_TD_SECONDS(self) != 0)
-		return PyBytes_FromFormat("%s(%d, %d)",
+		return PyString_FromFormat("%s(%d, %d)",
 					   Py_TYPE(self)->tp_name,
 					   GET_TD_DAYS(self),
 					   GET_TD_SECONDS(self));
 
-	return PyBytes_FromFormat("%s(%d)",
+	return PyString_FromFormat("%s(%d)",
 				   Py_TYPE(self)->tp_name,
 				   GET_TD_DAYS(self));
 }
@@ -2063,7 +2063,7 @@
 		pbuf += n;
 	}
 
-	return PyBytes_FromStringAndSize(buf, pbuf - buf);
+	return PyString_FromStringAndSize(buf, pbuf - buf);
 
  Fail:
 	PyErr_SetString(PyExc_SystemError, "goofy result from PyOS_snprintf");
@@ -2242,15 +2242,15 @@
 
 	/* Check for invocation from pickle with __getstate__ state */
 	if (PyTuple_GET_SIZE(args) == 1 &&
-	    PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
-	    PyBytes_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE &&
-	    MONTH_IS_SANE(PyBytes_AS_STRING(state)[2]))
+	    PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+	    PyString_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE &&
+	    MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
 	{
 	    	PyDateTime_Date *me;
 
 		me = (PyDateTime_Date *) (type->tp_alloc(type, 0));
 		if (me != NULL) {
-			char *pdata = PyBytes_AS_STRING(state);
+			char *pdata = PyString_AS_STRING(state);
 			memcpy(me->data, pdata, _PyDateTime_DATE_DATASIZE);
 			me->hashcode = -1;
 		}
@@ -2448,7 +2448,7 @@
 		      type_name,
 		      GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
 
-	return PyBytes_FromString(buffer);
+	return PyString_FromString(buffer);
 }
 
 static PyObject *
@@ -2457,7 +2457,7 @@
 	char buffer[128];
 
 	isoformat_date(self, buffer, sizeof(buffer));
-	return PyBytes_FromString(buffer);
+	return PyString_FromString(buffer);
 }
 
 /* str() calls the appropriate isoformat() method. */
@@ -2508,9 +2508,9 @@
 		return NULL;
 
 	/* Check for str or unicode */
-	if (PyBytes_Check(format)) {
+	if (PyString_Check(format)) {
                 /* If format is zero length, return str(self) */
-		if (PyBytes_GET_SIZE(format) == 0)
+		if (PyString_GET_SIZE(format) == 0)
 			return PyObject_Str((PyObject *)self);
 	} else if (PyUnicode_Check(format)) {
                 /* If format is zero length, return str(self) */
@@ -2653,7 +2653,7 @@
 {
 	return Py_BuildValue(
 		"(N)",
-		PyBytes_FromStringAndSize((char *)self->data,
+		PyString_FromStringAndSize((char *)self->data,
 					   _PyDateTime_DATE_DATASIZE));
 }
 
@@ -3109,9 +3109,9 @@
 	/* Check for invocation from pickle with __getstate__ state */
 	if (PyTuple_GET_SIZE(args) >= 1 &&
 	    PyTuple_GET_SIZE(args) <= 2 &&
-	    PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
-	    PyBytes_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE &&
-	    ((unsigned char) (PyBytes_AS_STRING(state)[0])) < 24)
+	    PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+	    PyString_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE &&
+	    ((unsigned char) (PyString_AS_STRING(state)[0])) < 24)
 	{
 		PyDateTime_Time *me;
 		char aware;
@@ -3127,7 +3127,7 @@
 		aware = (char)(tzinfo != Py_None);
 		me = (PyDateTime_Time *) (type->tp_alloc(type, aware));
 		if (me != NULL) {
-			char *pdata = PyBytes_AS_STRING(state);
+			char *pdata = PyString_AS_STRING(state);
 
 			memcpy(me->data, pdata, _PyDateTime_TIME_DATASIZE);
 			me->hashcode = -1;
@@ -3213,7 +3213,7 @@
 	else
 		PyOS_snprintf(buffer, sizeof(buffer),
 			      "%s(%d, %d)", type_name, h, m);
-	result = PyBytes_FromString(buffer);
+	result = PyString_FromString(buffer);
 	if (result != NULL && HASTZINFO(self))
 		result = append_keyword_tzinfo(result, self->tzinfo);
 	return result;
@@ -3240,7 +3240,7 @@
 	       _PyDateTime_TIME_DATASIZE);
 
 	isoformat_time(pdatetime, buf, sizeof(buf));
-	result = PyBytes_FromString(buf);
+	result = PyString_FromString(buf);
 	if (result == NULL || ! HASTZINFO(self) || self->tzinfo == Py_None)
 		return result;
 
@@ -3250,7 +3250,7 @@
 		Py_DECREF(result);
 		return NULL;
 	}
-	PyBytes_ConcatAndDel(&result, PyBytes_FromString(buf));
+	PyString_ConcatAndDel(&result, PyString_FromString(buf));
 	return result;
 }
 
@@ -3364,7 +3364,7 @@
 
 		/* Reduce this to a hash of another object. */
 		if (offset == 0)
-			temp = PyBytes_FromStringAndSize((char *)self->data,
+			temp = PyString_FromStringAndSize((char *)self->data,
 						_PyDateTime_TIME_DATASIZE);
 		else {
 			int hour;
@@ -3452,7 +3452,7 @@
 	PyObject *basestate;
 	PyObject *result = NULL;
 
-	basestate =  PyBytes_FromStringAndSize((char *)self->data,
+	basestate =  PyString_FromStringAndSize((char *)self->data,
 						_PyDateTime_TIME_DATASIZE);
 	if (basestate != NULL) {
 		if (! HASTZINFO(self) || self->tzinfo == Py_None)
@@ -3639,9 +3639,9 @@
 	/* Check for invocation from pickle with __getstate__ state */
 	if (PyTuple_GET_SIZE(args) >= 1 &&
 	    PyTuple_GET_SIZE(args) <= 2 &&
-	    PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
-	    PyBytes_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE &&
-	    MONTH_IS_SANE(PyBytes_AS_STRING(state)[2]))
+	    PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+	    PyString_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE &&
+	    MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
 	{
 		PyDateTime_DateTime *me;
 		char aware;
@@ -3657,7 +3657,7 @@
 		aware = (char)(tzinfo != Py_None);
 		me = (PyDateTime_DateTime *) (type->tp_alloc(type , aware));
 		if (me != NULL) {
-			char *pdata = PyBytes_AS_STRING(state);
+			char *pdata = PyString_AS_STRING(state);
 
 			memcpy(me->data, pdata, _PyDateTime_DATETIME_DATASIZE);
 			me->hashcode = -1;
@@ -4166,7 +4166,7 @@
 			      GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
 			      DATE_GET_HOUR(self), DATE_GET_MINUTE(self));
 	}
-	baserepr = PyBytes_FromString(buffer);
+	baserepr = PyString_FromString(buffer);
 	if (baserepr == NULL || ! HASTZINFO(self))
 		return baserepr;
 	return append_keyword_tzinfo(baserepr, self->tzinfo);
@@ -4194,7 +4194,7 @@
 	assert(cp != NULL);
 	*cp++ = sep;
 	isoformat_time(self, cp, sizeof(buffer) - (cp - buffer));
-	result = PyBytes_FromString(buffer);
+	result = PyString_FromString(buffer);
 	if (result == NULL || ! HASTZINFO(self))
 		return result;
 
@@ -4204,7 +4204,7 @@
 		Py_DECREF(result);
 		return NULL;
 	}
-	PyBytes_ConcatAndDel(&result, PyBytes_FromString(buffer));
+	PyString_ConcatAndDel(&result, PyString_FromString(buffer));
 	return result;
 }
 
@@ -4310,7 +4310,7 @@
 
 		/* Reduce this to a hash of another object. */
 		if (n == OFFSET_NAIVE)
-			temp = PyBytes_FromStringAndSize(
+			temp = PyString_FromStringAndSize(
 					(char *)self->data,
 					_PyDateTime_DATETIME_DATASIZE);
 		else {
@@ -4533,7 +4533,7 @@
 	PyObject *basestate;
 	PyObject *result = NULL;
 
-	basestate = PyBytes_FromStringAndSize((char *)self->data,
+	basestate = PyString_FromStringAndSize((char *)self->data,
 					  _PyDateTime_DATETIME_DATASIZE);
 	if (basestate != NULL) {
 		if (! HASTZINFO(self) || self->tzinfo == Py_None)
diff --git a/Modules/dbmmodule.c b/Modules/dbmmodule.c
index d5b518a..c91ea47 100644
--- a/Modules/dbmmodule.c
+++ b/Modules/dbmmodule.c
@@ -104,7 +104,7 @@
 	drec = dbm_fetch(dp->di_dbm, krec);
 	if ( drec.dptr == 0 ) {
 		PyErr_SetString(PyExc_KeyError,
-				PyBytes_AS_STRING((PyBytesObject *)key));
+				PyString_AS_STRING((PyStringObject *)key));
 		return NULL;
 	}
 	if ( dbm_error(dp->di_dbm) ) {
@@ -112,7 +112,7 @@
 		PyErr_SetString(DbmError, "");
 		return NULL;
 	}
-	return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
+	return PyString_FromStringAndSize(drec.dptr, drec.dsize);
 }
 
 static int
@@ -136,7 +136,7 @@
 		if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
 			dbm_clearerr(dp->di_dbm);
 			PyErr_SetString(PyExc_KeyError,
-				      PyBytes_AS_STRING((PyBytesObject *)v));
+				      PyString_AS_STRING((PyStringObject *)v));
 			return -1;
 		}
 	} else {
@@ -166,7 +166,7 @@
 {
 	datum key, val;
 
-	if (PyBytes_AsStringAndSize(v, (char **)&key.dptr,
+	if (PyString_AsStringAndSize(v, (char **)&key.dptr,
 	                             (Py_ssize_t *)&key.dsize)) {
 		return -1;
 	}
@@ -222,7 +222,7 @@
 		return NULL;
 	for (key = dbm_firstkey(dp->di_dbm); key.dptr;
 	     key = dbm_nextkey(dp->di_dbm)) {
-		item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+		item = PyString_FromStringAndSize(key.dptr, key.dsize);
 		if (item == NULL) {
 			Py_DECREF(v);
 			return NULL;
@@ -269,7 +269,7 @@
         check_dbmobject_open(dp);
 	val = dbm_fetch(dp->di_dbm, key);
 	if (val.dptr != NULL)
-		return PyBytes_FromStringAndSize(val.dptr, val.dsize);
+		return PyString_FromStringAndSize(val.dptr, val.dsize);
 	else {
 		Py_INCREF(defvalue);
 		return defvalue;
@@ -292,16 +292,16 @@
         check_dbmobject_open(dp);
 	val = dbm_fetch(dp->di_dbm, key);
 	if (val.dptr != NULL)
-		return PyBytes_FromStringAndSize(val.dptr, val.dsize);
+		return PyString_FromStringAndSize(val.dptr, val.dsize);
 	if (defvalue == NULL) {
-		defvalue = PyBytes_FromStringAndSize(NULL, 0);
+		defvalue = PyString_FromStringAndSize(NULL, 0);
 		if (defvalue == NULL)
 			return NULL;
 	}
 	else
 		Py_INCREF(defvalue);
-	val.dptr = PyBytes_AS_STRING(defvalue);
-	val.dsize = PyBytes_GET_SIZE(defvalue);
+	val.dptr = PyString_AS_STRING(defvalue);
+	val.dsize = PyString_GET_SIZE(defvalue);
 	if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
 		dbm_clearerr(dp->di_dbm);
 		PyErr_SetString(DbmError, "cannot add item to database");
@@ -404,7 +404,7 @@
 	d = PyModule_GetDict(m);
 	if (DbmError == NULL)
 		DbmError = PyErr_NewException("dbm.error", NULL, NULL);
-	s = PyBytes_FromString(which_dbm);
+	s = PyString_FromString(which_dbm);
 	if (s != NULL) {
 		PyDict_SetItemString(d, "library", s);
 		Py_DECREF(s);
diff --git a/Modules/dlmodule.c b/Modules/dlmodule.c
index e633fe9..ccf1cb1 100644
--- a/Modules/dlmodule.c
+++ b/Modules/dlmodule.c
@@ -58,8 +58,8 @@
 {
 	char *name;
 	PyUnivPtr *func;
-	if (PyBytes_Check(args)) {
-		name = PyBytes_AS_STRING(args);
+	if (PyString_Check(args)) {
+		name = PyString_AS_STRING(args);
 	} else {
 		PyErr_Format(PyExc_TypeError, "expected string, found %.200s",
 			     Py_TYPE(args)->tp_name);
@@ -88,14 +88,14 @@
 		return NULL;
 	}
 	name = PyTuple_GetItem(args, 0);
-	if (!PyBytes_Check(name)) {
+	if (!PyString_Check(name)) {
 		PyErr_SetString(PyExc_TypeError,
 				"function name must be a string");
 		return NULL;
 	}
 	func = (long (*)(long, long, long, long, long, 
                          long, long, long, long, long)) 
-          dlsym(xp->dl_handle, PyBytes_AsString(name));
+          dlsym(xp->dl_handle, PyString_AsString(name));
 	if (func == NULL) {
 		PyErr_SetString(PyExc_ValueError, dlerror());
 		return NULL;
@@ -109,8 +109,8 @@
 		PyObject *v = PyTuple_GetItem(args, i);
 		if (PyInt_Check(v))
 			alist[i-1] = PyInt_AsLong(v);
-		else if (PyBytes_Check(v))
-			alist[i-1] = (long)PyBytes_AsString(v);
+		else if (PyString_Check(v))
+			alist[i-1] = (long)PyString_AsString(v);
 		else if (v == Py_None)
 			alist[i-1] = (long) ((char *)NULL);
 		else {
diff --git a/Modules/errnomodule.c b/Modules/errnomodule.c
index df2ceff..696d396 100644
--- a/Modules/errnomodule.c
+++ b/Modules/errnomodule.c
@@ -21,7 +21,7 @@
 static void
 _inscode(PyObject *d, PyObject *de, char *name, int code)
 {
-	PyObject *u = PyBytes_FromString(name);
+	PyObject *u = PyString_FromString(name);
 	PyObject *v = PyInt_FromLong((long) code);
 
 	/* Don't bother checking for errors; they'll be caught at the end
diff --git a/Modules/fcntlmodule.c b/Modules/fcntlmodule.c
index 7658be0..0c85f47 100644
--- a/Modules/fcntlmodule.c
+++ b/Modules/fcntlmodule.c
@@ -55,7 +55,7 @@
 			PyErr_SetFromErrno(PyExc_IOError);
 			return NULL;
 		}
-		return PyBytes_FromStringAndSize(buf, len);
+		return PyString_FromStringAndSize(buf, len);
 	}
 
 	PyErr_Clear();
@@ -164,7 +164,7 @@
 			return PyInt_FromLong(ret);
 		}
 		else {
-			return PyBytes_FromStringAndSize(buf, len);
+			return PyString_FromStringAndSize(buf, len);
 		}
 	}
 
@@ -185,7 +185,7 @@
 			PyErr_SetFromErrno(PyExc_IOError);
 			return NULL;
 		}
-		return PyBytes_FromStringAndSize(buf, len);
+		return PyString_FromStringAndSize(buf, len);
 	}
 
 	PyErr_Clear();
diff --git a/Modules/flmodule.c b/Modules/flmodule.c
index 800aebb..20e74e9 100644
--- a/Modules/flmodule.c
+++ b/Modules/flmodule.c
@@ -324,7 +324,7 @@
 	/* "label" is an exception, getmember only works for char pointers,
 	   not for char arrays */
 	if (strcmp(name, "label") == 0)
-		return PyBytes_FromString(g->ob_generic->label);
+		return PyString_FromString(g->ob_generic->label);
 
 	return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
 }
@@ -343,12 +343,12 @@
 	/* "label" is an exception: setmember doesn't set strings;
 	   and FORMS wants you to call a function to set the label */
 	if (strcmp(name, "label") == 0) {
-		if (!PyBytes_Check(v)) {
+		if (!PyString_Check(v)) {
 			PyErr_SetString(PyExc_TypeError,
 					"label attr must be string");
 			return -1;
 		}
-		fl_set_object_label(g->ob_generic, PyBytes_AsString(v));
+		fl_set_object_label(g->ob_generic, PyString_AsString(v));
 		return 0;
 	}
 
@@ -369,7 +369,7 @@
 	char buf[100];
 	PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",
 		      g, g->ob_generic->objclass);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyTypeObject GenericObjecttype = {
@@ -530,7 +530,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString (str);
+	return PyString_FromString (str);
 }
 
 /* int func (object) */
@@ -628,7 +628,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString (str);
+	return PyString_FromString (str);
 }
 
 static PyObject *
@@ -1594,7 +1594,7 @@
 	char buf[100];
 	PyOS_snprintf(buf, sizeof(buf), "<FORMS_form at %p, window=%ld>",
 		      f, f->ob_form->window);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyTypeObject Formtype = {
@@ -2027,7 +2027,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(str);
+	return PyString_FromString(str);
 }
 
 static PyObject *
@@ -2046,7 +2046,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(str);
+	return PyString_FromString(str);
 }
 
 
@@ -2061,7 +2061,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(str);
+	return PyString_FromString(str);
 }
 
 static PyObject *
diff --git a/Modules/fmmodule.c b/Modules/fmmodule.c
index 73b8c05..f3f0dc5 100644
--- a/Modules/fmmodule.c
+++ b/Modules/fmmodule.c
@@ -66,7 +66,7 @@
 		PyErr_SetString(PyExc_RuntimeError, "error in fmgetfontname");
 		return NULL;
 	}
-	return PyBytes_FromStringAndSize(fontname, len);
+	return PyString_FromStringAndSize(fontname, len);
 }
 
 static PyObject *
@@ -79,7 +79,7 @@
 		PyErr_SetString(PyExc_RuntimeError, "error in fmgetcomment");
 		return NULL;
 	}
-	return PyBytes_FromStringAndSize(comment, len);
+	return PyString_FromStringAndSize(comment, len);
 }
 
 static PyObject *
@@ -200,7 +200,7 @@
 	PyObject *v;
 	if (fontlist == NULL)
 		return;
-	v = PyBytes_FromString(fontname);
+	v = PyString_FromString(fontname);
 	if (v == NULL)
 		err = -1;
 	else {
@@ -240,7 +240,7 @@
 static PyObject *
 fm_fontpath(PyObject *self)
 {
-	return PyBytes_FromString(fmfontpath());
+	return PyString_FromString(fmfontpath());
 }
 
 static PyMethodDef fm_methods[] = {
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
index c3ee96f..4f8c85f 100644
--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
@@ -639,8 +639,8 @@
 	char *cname;
 	/* simple version of instance_repr */
 	PyObject *classname = inst->in_class->cl_name;
-	if (classname != NULL && PyBytes_Check(classname))
-		cname = PyBytes_AsString(classname);
+	if (classname != NULL && PyString_Check(classname))
+		cname = PyString_AsString(classname);
 	else
 		cname = "?";
 	PySys_WriteStderr("gc: %.100s <%.100s instance at %p>\n",
@@ -754,7 +754,7 @@
 	double t1 = 0.0;
 
 	if (delstr == NULL) {
-		delstr = PyBytes_InternFromString("__del__");
+		delstr = PyString_InternFromString("__del__");
 		if (delstr == NULL)
 			Py_FatalError("gc couldn't allocate \"__del__\"");
 	}
@@ -898,7 +898,7 @@
 
 	if (PyErr_Occurred()) {
 		if (gc_str == NULL)
-			gc_str = PyBytes_FromString("garbage collection");
+			gc_str = PyString_FromString("garbage collection");
 		PyErr_WriteUnraisable(gc_str);
 		Py_FatalError("unexpected exception during garbage collection");
 	}
diff --git a/Modules/gdbmmodule.c b/Modules/gdbmmodule.c
index 89d9a3c..04b3332 100644
--- a/Modules/gdbmmodule.c
+++ b/Modules/gdbmmodule.c
@@ -128,10 +128,10 @@
     drec = gdbm_fetch(dp->di_dbm, krec);
     if (drec.dptr == 0) {
         PyErr_SetString(PyExc_KeyError,
-                        PyBytes_AS_STRING((PyBytesObject *)key));
+                        PyString_AS_STRING((PyStringObject *)key));
         return NULL;
     }
-    v = PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
+    v = PyString_FromStringAndSize(drec.dptr, drec.dsize);
     free(drec.dptr);
     return v;
 }
@@ -155,7 +155,7 @@
     if (w == NULL) {
         if (gdbm_delete(dp->di_dbm, krec) < 0) {
             PyErr_SetString(PyExc_KeyError,
-                            PyBytes_AS_STRING((PyBytesObject *)v));
+                            PyString_AS_STRING((PyStringObject *)v));
             return -1;
         }
     }
@@ -188,14 +188,14 @@
                         "GDBM object has already been closed");
         return -1;
     }
-    if (!PyBytes_Check(arg)) {
+    if (!PyString_Check(arg)) {
         PyErr_Format(PyExc_TypeError,
                      "gdbm key must be string, not %.100s",
                      arg->ob_type->tp_name);
         return -1;
     }
-    key.dptr = PyBytes_AS_STRING(arg);
-    key.dsize = PyBytes_GET_SIZE(arg);
+    key.dptr = PyString_AS_STRING(arg);
+    key.dsize = PyString_GET_SIZE(arg);
     return gdbm_exists(dp->di_dbm, key);
 }
 
@@ -255,7 +255,7 @@
 
     key = gdbm_firstkey(dp->di_dbm);
     while (key.dptr) {
-        item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+        item = PyString_FromStringAndSize(key.dptr, key.dsize);
         if (item == NULL) {
             free(key.dptr);
             Py_DECREF(v);
@@ -306,7 +306,7 @@
     check_dbmobject_open(dp);
     key = gdbm_firstkey(dp->di_dbm);
     if (key.dptr) {
-        v = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+        v = PyString_FromStringAndSize(key.dptr, key.dsize);
         free(key.dptr);
         return v;
     }
@@ -338,7 +338,7 @@
     check_dbmobject_open(dp);
     nextkey = gdbm_nextkey(dp->di_dbm, key);
     if (nextkey.dptr) {
-        v = PyBytes_FromStringAndSize(nextkey.dptr, nextkey.dsize);
+        v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize);
         free(nextkey.dptr);
         return v;
     }
@@ -541,7 +541,7 @@
     DbmError = PyErr_NewException("gdbm.error", NULL, NULL);
     if (DbmError != NULL) {
         PyDict_SetItemString(d, "error", DbmError);
-        s = PyBytes_FromString(dbmmodule_open_flags);
+        s = PyString_FromString(dbmmodule_open_flags);
         PyDict_SetItemString(d, "open_flags", s);
         Py_DECREF(s);
     }
diff --git a/Modules/glmodule.c b/Modules/glmodule.c
index 301a593..01db9fc 100644
--- a/Modules/glmodule.c
+++ b/Modules/glmodule.c
@@ -593,7 +593,7 @@
 #if 0
 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
 	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
-	if (!PyBytes_Check(s) || PyBytes_Size(s) != pixcount*sizeof(long)) {
+	if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
 		PyErr_SetString(PyExc_RuntimeError,
 			   "string arg to lrectwrite has wrong size");
 		return NULL;
@@ -623,10 +623,10 @@
 	if (!PyArg_GetShort(args, 4, 3, &y2))
 		return NULL;
 	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
-	parray = PyBytes_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+	parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 	if (parray == NULL)
 		return NULL; /* No memory */
-	lrectread(x1, y1, x2, y2, (unsigned long *) PyBytes_AsString(parray));
+	lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
 	return parray;
 }
 
@@ -642,10 +642,10 @@
 	if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
 	  return 0;
 	size = (long)(x2+1-x1) * (long)(y2+1-y1);
-	rv = PyBytes_FromStringAndSize((char *)NULL, size*sizeof(long));
+	rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
 	if ( rv == NULL )
 	  return NULL;
-	parray = (unsigned long *)PyBytes_AsString(rv);
+	parray = (unsigned long *)PyString_AsString(rv);
 	size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
 	if ( size_ret != size ) {
 	    printf("gl_readdisplay: got %ld pixels, expected %ld\n",
@@ -700,16 +700,16 @@
 	pixcount = width*height;
 	packedcount = ((width+packfactor-1)/packfactor) *
 		((height+packfactor-1)/packfactor);
-	if (PyBytes_Size(unpacked) != pixcount*sizeof(long)) {
+	if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
 		PyErr_SetString(PyExc_RuntimeError,
 			   "string arg to packrect has wrong size");
 		return NULL;
 	}
-	packed = PyBytes_FromStringAndSize((char *)NULL, packedcount);
+	packed = PyString_FromStringAndSize((char *)NULL, packedcount);
 	if (packed == NULL)
 		return NULL;
-	parray = (unsigned long *) PyBytes_AsString(unpacked);
-	p = (unsigned char *) PyBytes_AsString(packed);
+	parray = (unsigned long *) PyString_AsString(unpacked);
+	p = (unsigned char *) PyString_AsString(packed);
 	for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
 		for (x = 0; x < width; x += packfactor) {
 			pixel = parray[x];
@@ -758,16 +758,16 @@
 	pixcount = width*height;
 	packedcount = ((width+packfactor-1)/packfactor) *
 		((height+packfactor-1)/packfactor);
-	if (PyBytes_Size(packed) != packedcount) {
+	if (PyString_Size(packed) != packedcount) {
 		PyErr_SetString(PyExc_RuntimeError,
 			   "string arg to unpackrect has wrong size");
 		return NULL;
 	}
-	unpacked = PyBytes_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+	unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 	if (unpacked == NULL)
 		return NULL;
-	parray = (unsigned long *) PyBytes_AsString(unpacked);
-	p = (unsigned char *) PyBytes_AsString(packed);
+	parray = (unsigned long *) PyString_AsString(unpacked);
+	p = (unsigned char *) PyString_AsString(packed);
 	if (packfactor == 1 && width*height > 0) {
 		/* Just expand bytes to longs */
 		register int x = width * height;
@@ -799,7 +799,7 @@
 {
 	char buf[20];
 	gversion(buf);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 
diff --git a/Modules/grpmodule.c b/Modules/grpmodule.c
index 74bf0dc..e5b9f47 100644
--- a/Modules/grpmodule.c
+++ b/Modules/grpmodule.c
@@ -47,7 +47,7 @@
         return NULL;
     }
     for (member = p->gr_mem; *member != NULL; member++) {
-        PyObject *x = PyBytes_FromString(*member);
+        PyObject *x = PyString_FromString(*member);
         if (x == NULL || PyList_Append(w, x) != 0) {
             Py_XDECREF(x);
             Py_DECREF(w);
@@ -58,13 +58,13 @@
     }
 
 #define SET(i,val) PyStructSequence_SET_ITEM(v, i, val)
-    SET(setIndex++, PyBytes_FromString(p->gr_name));
+    SET(setIndex++, PyString_FromString(p->gr_name));
 #ifdef __VMS
     SET(setIndex++, Py_None);
     Py_INCREF(Py_None);
 #else
     if (p->gr_passwd)
-	    SET(setIndex++, PyBytes_FromString(p->gr_passwd));
+	    SET(setIndex++, PyString_FromString(p->gr_passwd));
     else {
 	    SET(setIndex++, Py_None);
 	    Py_INCREF(Py_None);
@@ -113,7 +113,7 @@
     py_str_name = PyObject_Str(pyo_name);
     if (!py_str_name)
 	    return NULL;
-    name = PyBytes_AS_STRING(py_str_name);
+    name = PyString_AS_STRING(py_str_name);
     
     if ((p = getgrnam(name)) == NULL) {
 	PyErr_Format(PyExc_KeyError, "getgrnam(): name not found: %s", name);
diff --git a/Modules/imageop.c b/Modules/imageop.c
index 105bedc..f67cd60 100644
--- a/Modules/imageop.c
+++ b/Modules/imageop.c
@@ -54,7 +54,7 @@
 		return 1;
 	if (bcos == NULL) {
 		/* cache string object for future use */
-		bcos = PyBytes_FromString("backward_compatible");
+		bcos = PyString_FromString("backward_compatible");
 		if (bcos == NULL)
 			return 1;
 	}
@@ -97,11 +97,11 @@
 	xstep = (newx1 < newx2)? 1 : -1;
 	ystep = (newy1 < newy2)? 1 : -1;
     
-	rv = PyBytes_FromStringAndSize(NULL,
+	rv = PyString_FromStringAndSize(NULL,
 			     (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size);
 	if ( rv == 0 )
 		return 0;
-	ncp = (char *)PyBytes_AsString(rv);
+	ncp = (char *)PyString_AsString(rv);
 	nsp = (short *)ncp;
 	nlp = (Py_Int32 *)ncp;
 	newy2 += ystep;
@@ -150,10 +150,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, newx*newy*size);
+	rv = PyString_FromStringAndSize(NULL, newx*newy*size);
 	if ( rv == 0 )
 		return 0;
-	ncp = (char *)PyBytes_AsString(rv);
+	ncp = (char *)PyString_AsString(rv);
 	nsp = (short *)ncp;
 	nlp = (Py_Int32 *)ncp;
 	for( iy = 0; iy < newy; iy++ ) {
@@ -195,10 +195,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, len);
+	rv = PyString_FromStringAndSize(NULL, len);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	if ( width == 1 ) {
 		memcpy(ncp, cp, maxx);		/* Copy first line */
@@ -245,10 +245,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, (len+7)/8);
+	rv = PyString_FromStringAndSize(NULL, (len+7)/8);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	bit = 0x80;
 	ovalue = 0;
@@ -286,10 +286,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, (len+1)/2);
+	rv = PyString_FromStringAndSize(NULL, (len+1)/2);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 	pos = 0;
 	ovalue = 0;
 	for ( i=0; i < len; i++ ) {
@@ -325,10 +325,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, (len+3)/4);
+	rv = PyString_FromStringAndSize(NULL, (len+3)/4);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 	pos = 0;
 	ovalue = 0;
 	for ( i=0; i < len; i++ ) {
@@ -363,10 +363,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, (len+7)/8);
+	rv = PyString_FromStringAndSize(NULL, (len+7)/8);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	bit = 0x80;
 	ovalue = 0;
@@ -409,10 +409,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, (len+3)/4);
+	rv = PyString_FromStringAndSize(NULL, (len+3)/4);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 	pos = 1;
 	ovalue = 0;
 	for ( i=0; i < len; i++ ) {
@@ -449,10 +449,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen);
+	rv = PyString_FromStringAndSize(NULL, nlen);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	bit = 0x80;
 	for ( i=0; i < nlen; i++ ) {
@@ -486,10 +486,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen);
+	rv = PyString_FromStringAndSize(NULL, nlen);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	pos = 0;
 	for ( i=0; i < nlen; i++ ) {
@@ -522,10 +522,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen);
+	rv = PyString_FromStringAndSize(NULL, nlen);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	pos = 0;
 	for ( i=0; i < nlen; i++ ) {
@@ -559,10 +559,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen);
+	rv = PyString_FromStringAndSize(NULL, nlen);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	for ( i=0; i < nlen; i++ ) {
 		/* Bits in source: aaaaaaaa BBbbbbbb GGGggggg RRRrrrrr */
@@ -603,10 +603,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen*4);
+	rv = PyString_FromStringAndSize(NULL, nlen*4);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	for ( i=0; i < nlen; i++ ) {
 		/* Bits in source: RRRBBGGG
@@ -653,10 +653,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen);
+	rv = PyString_FromStringAndSize(NULL, nlen);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	for ( i=0; i < nlen; i++ ) {
 		if (backward_compatible) {
@@ -698,10 +698,10 @@
 		return 0;
 	}
     
-	rv = PyBytes_FromStringAndSize(NULL, nlen*4);
+	rv = PyString_FromStringAndSize(NULL, nlen*4);
 	if ( rv == 0 )
 		return 0;
-	ncp = (unsigned char *)PyBytes_AsString(rv);
+	ncp = (unsigned char *)PyString_AsString(rv);
 
 	for ( i=0; i < nlen; i++ ) {
 		value = *cp++;
diff --git a/Modules/imgfile.c b/Modules/imgfile.c
index 5a8adf2..baa6ead 100644
--- a/Modules/imgfile.c
+++ b/Modules/imgfile.c
@@ -130,12 +130,12 @@
 	}
 
 	if ( zsize == 3 ) zsize = 4;
-	rv = PyBytes_FromStringAndSize((char *)NULL, xsize*ysize*zsize);
+	rv = PyString_FromStringAndSize((char *)NULL, xsize*ysize*zsize);
 	if ( rv == NULL ) {
 		iclose(image);
 		return NULL;
 	}
-	cdatap = PyBytes_AsString(rv);
+	cdatap = PyString_AsString(rv);
 	idatap = (long *)cdatap;
 
 	if (top_to_bottom) {
@@ -319,7 +319,7 @@
 	}
 
 	if ( zsize == 3 ) zsize = 4;
-	rv = PyBytes_FromStringAndSize(NULL, xwtd*ywtd*zsize);
+	rv = PyString_FromStringAndSize(NULL, xwtd*ywtd*zsize);
 	if ( rv == NULL ) {
 		iclose(image);
 		return NULL;
@@ -328,7 +328,7 @@
 	xfac = (float)xsize/(float)xwtd;
 	yfac = (float)ysize/(float)ywtd;
 	PyFPE_END_PROTECT(yfac)
-	cdatap = PyBytes_AsString(rv);
+	cdatap = PyString_AsString(rv);
 	idatap = (long *)cdatap;
 
 	if ( extended ) {
diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c
index f466b91..261e8f1 100644
--- a/Modules/itertoolsmodule.c
+++ b/Modules/itertoolsmodule.c
@@ -2904,12 +2904,12 @@
 	PyObject *result;
 
         if (lz->cnt != PY_SSIZE_T_MAX)
-		return PyBytes_FromFormat("count(%zd)", lz->cnt);
+		return PyString_FromFormat("count(%zd)", lz->cnt);
 
 	cnt_repr = PyObject_Repr(lz->long_cnt);
 	if (cnt_repr == NULL)
 		return NULL;
-	result = PyBytes_FromFormat("count(%s)", PyBytes_AS_STRING(cnt_repr));
+	result = PyString_FromFormat("count(%s)", PyString_AS_STRING(cnt_repr));
 	Py_DECREF(cnt_repr);
 	return result;
 }
@@ -3221,11 +3221,11 @@
 		return NULL;
 
 	if (ro->cnt == -1)
-		result = PyBytes_FromFormat("repeat(%s)",
-			PyBytes_AS_STRING(objrepr));
+		result = PyString_FromFormat("repeat(%s)",
+			PyString_AS_STRING(objrepr));
 	else
-		result = PyBytes_FromFormat("repeat(%s, %zd)",
-			PyBytes_AS_STRING(objrepr), ro->cnt);
+		result = PyString_FromFormat("repeat(%s, %zd)",
+			PyString_AS_STRING(objrepr), ro->cnt);
 	Py_DECREF(objrepr);
 	return result;
 }	
diff --git a/Modules/linuxaudiodev.c b/Modules/linuxaudiodev.c
index bde6e49..80077c6 100644
--- a/Modules/linuxaudiodev.c
+++ b/Modules/linuxaudiodev.c
@@ -162,17 +162,17 @@
 	
     if (!PyArg_ParseTuple(args, "i:read", &size))
         return NULL;
-    rv = PyBytes_FromStringAndSize(NULL, size);
+    rv = PyString_FromStringAndSize(NULL, size);
     if (rv == NULL)
         return NULL;
-    cp = PyBytes_AS_STRING(rv);
+    cp = PyString_AS_STRING(rv);
     if ((count = read(self->x_fd, cp, size)) < 0) {
         PyErr_SetFromErrno(LinuxAudioError);
         Py_DECREF(rv);
         return NULL;
     }
     self->x_icount += count;
-    _PyBytes_Resize(&rv, count);
+    _PyString_Resize(&rv, count);
     return rv;
 }
 
diff --git a/Modules/main.c b/Modules/main.c
index c1c4b45..895a64f 100644
--- a/Modules/main.c
+++ b/Modules/main.c
@@ -196,7 +196,7 @@
 {
 	PyObject *argv0 = NULL, *importer = NULL;
 
-	if ((argv0 = PyBytes_FromString(filename)) && 
+	if ((argv0 = PyString_FromString(filename)) && 
 	    (importer = PyImport_GetImporter(argv0)) &&
 	    (importer->ob_type != &PyNullImporter_Type))
 	{
diff --git a/Modules/md5module.c b/Modules/md5module.c
index 7095202..1e2e6e3 100644
--- a/Modules/md5module.c
+++ b/Modules/md5module.c
@@ -80,7 +80,7 @@
 	mdContext = self->md5;
 	md5_finish(&mdContext, aDigest);
 
-	return PyBytes_FromStringAndSize((char *)aDigest, 16);
+	return PyString_FromStringAndSize((char *)aDigest, 16);
 }
 
 PyDoc_STRVAR(digest_doc,
@@ -113,7 +113,7 @@
 		c = (c>9) ? c+'a'-10 : c + '0';
 		hexdigest[j++] = c;
 	}
-	return PyBytes_FromStringAndSize((char*)hexdigest, 32);
+	return PyString_FromStringAndSize((char*)hexdigest, 32);
 }
 
 
@@ -165,7 +165,7 @@
 static PyObject *
 md5_get_name(PyObject *self, void *closure)
 {
-    return PyBytes_FromStringAndSize("MD5", 3);
+    return PyString_FromStringAndSize("MD5", 3);
 }
 
 static PyGetSetDef md5_getseters[] = {
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index 73fdf6d..c71d840 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -222,7 +222,7 @@
 	else
 		++eol;		/* we're interested in the position after the
 				   newline. */
-	result = PyBytes_FromStringAndSize(start, (eol - start));
+	result = PyString_FromStringAndSize(start, (eol - start));
 	self->pos += (eol - start);
 	return result;
 }
@@ -700,7 +700,7 @@
 		PyErr_SetString(PyExc_IndexError, "mmap index out of range");
 		return NULL;
 	}
-	return PyBytes_FromStringAndSize(self->data + i, 1);
+	return PyString_FromStringAndSize(self->data + i, 1);
 }
 
 static PyObject *
@@ -718,7 +718,7 @@
 	else if ((size_t)ihigh > self->size)
 		ihigh = self->size;
 
-	return PyBytes_FromStringAndSize(self->data + ilow, ihigh-ilow);
+	return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
 }
 
 static PyObject *
@@ -736,7 +736,7 @@
 				"mmap index out of range");
 			return NULL;
 		}
-		return PyBytes_FromStringAndSize(self->data + i, 1);
+		return PyString_FromStringAndSize(self->data + i, 1);
 	}
 	else if (PySlice_Check(item)) {
 		Py_ssize_t start, stop, step, slicelen;
@@ -747,9 +747,9 @@
 		}
 		
 		if (slicelen <= 0)
-			return PyBytes_FromStringAndSize("", 0);
+			return PyString_FromStringAndSize("", 0);
 		else if (step == 1)
-			return PyBytes_FromStringAndSize(self->data + start,
+			return PyString_FromStringAndSize(self->data + start,
 							  slicelen);
 		else {
 			char *result_buf = (char *)PyMem_Malloc(slicelen);
@@ -762,7 +762,7 @@
 			     cur += step, i++) {
 			     	result_buf[i] = self->data[cur];
 			}
-			result = PyBytes_FromStringAndSize(result_buf,
+			result = PyString_FromStringAndSize(result_buf,
 							    slicelen);
 			PyMem_Free(result_buf);
 			return result;
@@ -815,19 +815,19 @@
 				"mmap object doesn't support slice deletion");
 		return -1;
 	}
-	if (! (PyBytes_Check(v)) ) {
+	if (! (PyString_Check(v)) ) {
 		PyErr_SetString(PyExc_IndexError,
 				"mmap slice assignment must be a string");
 		return -1;
 	}
-	if (PyBytes_Size(v) != (ihigh - ilow)) {
+	if (PyString_Size(v) != (ihigh - ilow)) {
 		PyErr_SetString(PyExc_IndexError,
 				"mmap slice assignment is wrong size");
 		return -1;
 	}
 	if (!is_writeable(self))
 		return -1;
-	buf = PyBytes_AsString(v);
+	buf = PyString_AsString(v);
 	memcpy(self->data + ilow, buf, ihigh-ilow);
 	return 0;
 }
@@ -847,14 +847,14 @@
 				"mmap object doesn't support item deletion");
 		return -1;
 	}
-	if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {
+	if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
 		PyErr_SetString(PyExc_IndexError,
 				"mmap assignment must be single-character string");
 		return -1;
 	}
 	if (!is_writeable(self))
 		return -1;
-	buf = PyBytes_AsString(v);
+	buf = PyString_AsString(v);
 	self->data[i] = buf[0];
 	return 0;
 }
@@ -882,14 +882,14 @@
 				"mmap object doesn't support item deletion");
 			return -1;
 		}
-		if (!PyBytes_Check(value) || PyBytes_Size(value) != 1) {
+		if (!PyString_Check(value) || PyString_Size(value) != 1) {
 			PyErr_SetString(PyExc_IndexError,
 		          "mmap assignment must be single-character string");
 			return -1;
 		}
 		if (!is_writeable(self))
 			return -1;
-		buf = PyBytes_AsString(value);
+		buf = PyString_AsString(value);
 		self->data[i] = buf[0];
 		return 0;
 	}
@@ -906,12 +906,12 @@
 				"mmap object doesn't support slice deletion");
 			return -1;
 		}
-		if (!PyBytes_Check(value)) {
+		if (!PyString_Check(value)) {
 			PyErr_SetString(PyExc_IndexError,
 				"mmap slice assignment must be a string");
 			return -1;
 		}
-		if (PyBytes_Size(value) != slicelen) {
+		if (PyString_Size(value) != slicelen) {
 			PyErr_SetString(PyExc_IndexError,
 				"mmap slice assignment is wrong size");
 			return -1;
@@ -922,7 +922,7 @@
 		if (slicelen == 0)
 			return 0;
 		else if (step == 1) {
-			const char *buf = PyBytes_AsString(value);
+			const char *buf = PyString_AsString(value);
 
 			if (buf == NULL)
 				return -1;
@@ -931,7 +931,7 @@
 		}
 		else {
 			Py_ssize_t cur, i;
-			const char *buf = PyBytes_AsString(value);
+			const char *buf = PyString_AsString(value);
 			
 			if (buf == NULL)
 				return -1;
diff --git a/Modules/nismodule.c b/Modules/nismodule.c
index 8dd1d96..0811430 100644
--- a/Modules/nismodule.c
+++ b/Modules/nismodule.c
@@ -115,8 +115,8 @@
 		    if (invallen > 0 && inval[invallen-1] == '\0')
 			invallen--;
 		}
-		key = PyBytes_FromStringAndSize(inkey, inkeylen);
-		val = PyBytes_FromStringAndSize(inval, invallen);
+		key = PyString_FromStringAndSize(inkey, inkeylen);
+		val = PyString_FromStringAndSize(inval, invallen);
 		if (key == NULL || val == NULL) {
 			/* XXX error -- don't know how to handle */
 			PyErr_Clear();
@@ -146,7 +146,7 @@
 	if ((err = yp_get_default_domain(&domain)) != 0)
 		return nis_error(err);
 
-	res = PyBytes_FromStringAndSize (domain, strlen(domain));
+	res = PyString_FromStringAndSize (domain, strlen(domain));
 	return res;
 }
 
@@ -178,7 +178,7 @@
 	    len--;
 	if (err != 0)
 		return nis_error(err);
-	res = PyBytes_FromStringAndSize (match, len);
+	res = PyString_FromStringAndSize (match, len);
 	free (match);
 	return res;
 }
@@ -398,7 +398,7 @@
 	if ((list = PyList_New(0)) == NULL)
 		return NULL;
 	for (maps = maps; maps; maps = maps->next) {
-		PyObject *str = PyBytes_FromString(maps->map);
+		PyObject *str = PyString_FromString(maps->map);
 		if (!str || PyList_Append(list, str) < 0)
 		{
 			Py_DECREF(list);
diff --git a/Modules/operator.c b/Modules/operator.c
index 7e44739..fd98efd 100644
--- a/Modules/operator.c
+++ b/Modules/operator.c
@@ -508,19 +508,19 @@
 	}
 #endif
 	
-	if (!PyBytes_Check(attr)) {
+	if (!PyString_Check(attr)) {
 		PyErr_SetString(PyExc_TypeError,
 				"attribute name must be a string");
 		return NULL;
 	}
 
-	s = PyBytes_AS_STRING(attr);
+	s = PyString_AS_STRING(attr);
 	Py_INCREF(obj);
 	for (;;) {
 		PyObject *newobj, *str;
 		p = strchr(s, '.');
-		str = p ? PyBytes_FromStringAndSize(s, (p-s)) : 
-			  PyBytes_FromString(s);
+		str = p ? PyString_FromStringAndSize(s, (p-s)) : 
+			  PyString_FromString(s);
 		if (str == NULL) {
 			Py_DECREF(obj);
 			return NULL;
diff --git a/Modules/ossaudiodev.c b/Modules/ossaudiodev.c
index 75f6c15..ebf101a 100644
--- a/Modules/ossaudiodev.c
+++ b/Modules/ossaudiodev.c
@@ -366,10 +366,10 @@
 
     if (!PyArg_ParseTuple(args, "i:read", &size))
         return NULL;
-    rv = PyBytes_FromStringAndSize(NULL, size);
+    rv = PyString_FromStringAndSize(NULL, size);
     if (rv == NULL)
         return NULL;
-    cp = PyBytes_AS_STRING(rv);
+    cp = PyString_AS_STRING(rv);
 
     Py_BEGIN_ALLOW_THREADS
     count = read(self->fd, cp, size);
@@ -381,7 +381,7 @@
         return NULL;
     }
     self->icount += count;
-    _PyBytes_Resize(&rv, count);
+    _PyString_Resize(&rv, count);
     return rv;
 }
 
@@ -811,20 +811,20 @@
         Py_INCREF(rval);
     }
     else if (strcmp(name, "name") == 0) {
-        rval = PyBytes_FromString(self->devicename);
+        rval = PyString_FromString(self->devicename);
     }
     else if (strcmp(name, "mode") == 0) {
         /* No need for a "default" in this switch: from newossobject(),
            self->mode can only be one of these three values. */
         switch(self->mode) {
             case O_RDONLY:
-                rval = PyBytes_FromString("r");
+                rval = PyString_FromString("r");
                 break;
             case O_RDWR:
-                rval = PyBytes_FromString("rw");
+                rval = PyString_FromString("rw");
                 break;
             case O_WRONLY:
-                rval = PyBytes_FromString("w");
+                rval = PyString_FromString("w");
                 break;
         }
     }
@@ -913,12 +913,12 @@
     if (labels == NULL || names == NULL)
         goto error2;
     for (i = 0; i < num_controls; i++) {
-        s = PyBytes_FromString(control_labels[i]);
+        s = PyString_FromString(control_labels[i]);
         if (s == NULL)
             goto error2;
         PyList_SET_ITEM(labels, i, s);
 
-        s = PyBytes_FromString(control_names[i]);
+        s = PyString_FromString(control_names[i]);
         if (s == NULL)
             goto error2;
         PyList_SET_ITEM(names, i, s);
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index 2ff67f2..6e52343 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -105,14 +105,14 @@
         }
 
         if (TYPE(n) == encoding_decl)
-            (void) addelem(v, i+1, PyBytes_FromString(STR(n)));
+            (void) addelem(v, i+1, PyString_FromString(STR(n)));
         return (v);
     }
     else if (ISTERMINAL(TYPE(n))) {
         PyObject *result = mkseq(2 + lineno + col_offset);
         if (result != NULL) {
             (void) addelem(result, 0, PyInt_FromLong(TYPE(n)));
-            (void) addelem(result, 1, PyBytes_FromString(STR(n)));
+            (void) addelem(result, 1, PyString_FromString(STR(n)));
             if (lineno == 1)
                 (void) addelem(result, 2, PyInt_FromLong(n->n_lineno));
             if (col_offset == 1)
@@ -689,7 +689,7 @@
             temp = PySequence_GetItem(elem, 1);
             if (temp == NULL)
                 return 0;
-            if (!PyBytes_Check(temp)) {
+            if (!PyString_Check(temp)) {
                 PyErr_Format(parser_error,
                              "second item in terminal node must be a string,"
                              " found %s",
@@ -714,10 +714,10 @@
                     Py_DECREF(o);
                 }
             }
-            len = PyBytes_GET_SIZE(temp) + 1;
+            len = PyString_GET_SIZE(temp) + 1;
             strn = (char *)PyObject_MALLOC(len);
             if (strn != NULL)
-                (void) memcpy(strn, PyBytes_AS_STRING(temp), len);
+                (void) memcpy(strn, PyString_AS_STRING(temp), len);
             Py_DECREF(temp);
         }
         else if (!ISNONTERMINAL(type)) {
@@ -800,10 +800,10 @@
             }
             if (res && encoding) {
                 Py_ssize_t len;
-                len = PyBytes_GET_SIZE(encoding) + 1;
+                len = PyString_GET_SIZE(encoding) + 1;
                 res->n_str = (char *)PyObject_MALLOC(len);
                 if (res->n_str != NULL)
-                    (void) memcpy(res->n_str, PyBytes_AS_STRING(encoding), len);
+                    (void) memcpy(res->n_str, PyString_AS_STRING(encoding), len);
                 Py_DECREF(encoding);
                 Py_DECREF(tuple);
             }
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 57fe088..a4bbac5 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -375,12 +375,12 @@
 		char *p = strchr(*e, '=');
 		if (p == NULL)
 			continue;
-		k = PyBytes_FromStringAndSize(*e, (int)(p-*e));
+		k = PyString_FromStringAndSize(*e, (int)(p-*e));
 		if (k == NULL) {
 			PyErr_Clear();
 			continue;
 		}
-		v = PyBytes_FromString(p+1);
+		v = PyString_FromString(p+1);
 		if (v == NULL) {
 			PyErr_Clear();
 			Py_DECREF(k);
@@ -400,13 +400,13 @@
 
         rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);
 	if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
-            PyObject *v = PyBytes_FromString(buffer);
+            PyObject *v = PyString_FromString(buffer);
 		    PyDict_SetItemString(d, "BEGINLIBPATH", v);
             Py_DECREF(v);
         }
         rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);
         if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */
-            PyObject *v = PyBytes_FromString(buffer);
+            PyObject *v = PyString_FromString(buffer);
 		    PyDict_SetItemString(d, "ENDLIBPATH", v);
             Py_DECREF(v);
         }
@@ -1598,7 +1598,7 @@
 #endif
 	if (ret == NULL)
 		return posix_error();
-	return PyBytes_FromString(ret);
+	return PyString_FromString(ret);
 }
 #endif
 
@@ -1620,7 +1620,7 @@
 #endif
 	if (ret == NULL)
 		return posix_error();
-	return PyBytes_FromString(buffer);
+	return PyString_FromString(buffer);
 }
 #endif
 
@@ -1968,7 +1968,7 @@
 	Py_END_ALLOW_THREADS
 	if (res == NULL)
 		return posix_error();
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 #ifdef Py_USING_UNICODE
@@ -2174,7 +2174,7 @@
 		/* Skip over . and .. */
 		if (strcmp(FileData.cFileName, ".") != 0 &&
 		    strcmp(FileData.cFileName, "..") != 0) {
-			v = PyBytes_FromString(FileData.cFileName);
+			v = PyString_FromString(FileData.cFileName);
 			if (v == NULL) {
 				Py_DECREF(d);
 				d = NULL;
@@ -2262,7 +2262,7 @@
             /* Leave Case of Name Alone -- In Native Form */
             /* (Removed Forced Lowercasing Code) */
 
-            v = PyBytes_FromString(namebuf);
+            v = PyString_FromString(namebuf);
             if (v == NULL) {
                 Py_DECREF(d);
                 d = NULL;
@@ -2312,7 +2312,7 @@
 		    (NAMLEN(ep) == 1 ||
 		     (ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
 			continue;
-		v = PyBytes_FromStringAndSize(ep->d_name, NAMLEN(ep));
+		v = PyString_FromStringAndSize(ep->d_name, NAMLEN(ep));
 		if (v == NULL) {
 			Py_DECREF(d);
 			d = NULL;
@@ -2397,7 +2397,7 @@
 		return PyUnicode_Decode(outbuf, strlen(outbuf),
 			Py_FileSystemDefaultEncoding, NULL);
 	}
-	return PyBytes_FromString(outbuf);
+	return PyString_FromString(outbuf);
 } /* end of posix__getfullpathname */
 #endif /* MS_WINDOWS */
 
@@ -3062,7 +3062,7 @@
         /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
         if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) {
 #endif
-		len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+		len = PyString_Size(key) + PyString_Size(val) + 2;
 		p = PyMem_NEW(char, len);
 		if (p == NULL) {
 			PyErr_NoMemory();
@@ -3292,7 +3292,7 @@
 		{
 			goto fail_2;
 		}
-		len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+		len = PyString_Size(key) + PyString_Size(val) + 2;
 		p = PyMem_NEW(char, len);
 		if (p == NULL) {
 			PyErr_NoMemory();
@@ -3525,7 +3525,7 @@
 		{
 			goto fail_2;
 		}
-		len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+		len = PyString_Size(key) + PyString_Size(val) + 2;
 		p = PyMem_NEW(char, len);
 		if (p == NULL) {
 			PyErr_NoMemory();
@@ -3895,7 +3895,7 @@
                                 "unable to determine login name");
         }
         else
-            result = PyBytes_FromString(name);
+            result = PyString_FromString(name);
         errno = old_errno;
 
     return result;
@@ -5884,7 +5884,7 @@
 		return posix_error_with_allocated_filename(path);
 
 	PyMem_Free(path);
-	v = PyBytes_FromStringAndSize(buf, n);
+	v = PyString_FromStringAndSize(buf, n);
 #ifdef Py_USING_UNICODE
 	if (arg_is_unicode) {
 		PyObject *w;
@@ -6289,18 +6289,18 @@
 		errno = EINVAL;
 		return posix_error();
 	}
-	buffer = PyBytes_FromStringAndSize((char *)NULL, size);
+	buffer = PyString_FromStringAndSize((char *)NULL, size);
 	if (buffer == NULL)
 		return NULL;
 	Py_BEGIN_ALLOW_THREADS
-	n = read(fd, PyBytes_AsString(buffer), size);
+	n = read(fd, PyString_AsString(buffer), size);
 	Py_END_ALLOW_THREADS
 	if (n < 0) {
 		Py_DECREF(buffer);
 		return posix_error();
 	}
 	if (n != size)
-		_PyBytes_Resize(&buffer, n);
+		_PyString_Resize(&buffer, n);
 	return buffer;
 }
 
@@ -6647,11 +6647,11 @@
 	/* XXX This can leak memory -- not easy to fix :-( */
 	len = strlen(s1) + strlen(s2) + 2;
 	/* len includes space for a trailing \0; the size arg to
-	   PyBytes_FromStringAndSize does not count that */
-	newstr = PyBytes_FromStringAndSize(NULL, (int)len - 1);
+	   PyString_FromStringAndSize does not count that */
+	newstr = PyString_FromStringAndSize(NULL, (int)len - 1);
 	if (newstr == NULL)
 		return PyErr_NoMemory();
-	newenv = PyBytes_AS_STRING(newstr);
+	newenv = PyString_AS_STRING(newstr);
 	PyOS_snprintf(newenv, len, "%s=%s", s1, s2);
 	if (putenv(newenv)) {
                 Py_DECREF(newstr);
@@ -6727,7 +6727,7 @@
 				"strerror() argument out of range");
 		return NULL;
 	}
-	return PyBytes_FromString(message);
+	return PyString_FromString(message);
 }
 
 
@@ -7009,7 +7009,7 @@
 #endif
     if (name == NULL)
         return PyErr_NoMemory();
-    result = PyBytes_FromString(name);
+    result = PyString_FromString(name);
     free(name);
     return result;
 }
@@ -7066,7 +7066,7 @@
 	Py_XDECREF(err);
 	return NULL;
     }
-    return PyBytes_FromString(buffer);
+    return PyString_FromString(buffer);
 }
 #endif
 
@@ -7095,13 +7095,13 @@
         *valuep = PyInt_AS_LONG(arg);
         return 1;
     }
-    if (PyBytes_Check(arg)) {
+    if (PyString_Check(arg)) {
         /* look up the value in the table using a binary search */
         size_t lo = 0;
 		size_t mid;
         size_t hi = tablesize;
         int cmp;
-        char *confname = PyBytes_AS_STRING(arg);
+        char *confname = PyString_AS_STRING(arg);
         while (lo < hi) {
             mid = (lo + hi) / 2;
             cmp = strcmp(confname, table[mid].name);
@@ -7431,12 +7431,12 @@
         }
         else {
 	    if ((unsigned int)len >= sizeof(buffer)) {
-                result = PyBytes_FromStringAndSize(NULL, len-1);
+                result = PyString_FromStringAndSize(NULL, len-1);
                 if (result != NULL)
-                    confstr(name, PyBytes_AS_STRING(result), len);
+                    confstr(name, PyString_AS_STRING(result), len);
             }
             else
-                result = PyBytes_FromStringAndSize(buffer, len-1);
+                result = PyString_FromStringAndSize(buffer, len-1);
         }
     }
     return result;
@@ -8225,11 +8225,11 @@
 	}
 
 	/* Allocate bytes */
-	result = PyBytes_FromStringAndSize(NULL, howMany);
+	result = PyString_FromStringAndSize(NULL, howMany);
 	if (result != NULL) {
 		/* Get random data */
 		if (! pCryptGenRandom(hCryptProv, howMany, (unsigned char*)
-				      PyBytes_AS_STRING(result))) {
+				      PyString_AS_STRING(result))) {
 			Py_DECREF(result);
 			return win32_error("CryptGenRandom", NULL);
 		}
@@ -8259,11 +8259,11 @@
 				    "negative argument not allowed");
 
 	/* Allocate bytes */
-	result = PyBytes_FromStringAndSize(NULL, howMany);
+	result = PyString_FromStringAndSize(NULL, howMany);
 	if (result != NULL) {
 		/* Get random data */
 		if (RAND_pseudo_bytes((unsigned char*)
-				      PyBytes_AS_STRING(result),
+				      PyString_AS_STRING(result),
 				      howMany) < 0) {
 			Py_DECREF(result);
 			return PyErr_Format(PyExc_ValueError,
diff --git a/Modules/pwdmodule.c b/Modules/pwdmodule.c
index dff1bcb..9e01f48 100644
--- a/Modules/pwdmodule.c
+++ b/Modules/pwdmodule.c
@@ -49,7 +49,7 @@
 sets(PyObject *v, int i, char* val)
 {
   if (val)
-	  PyStructSequence_SET_ITEM(v, i, PyBytes_FromString(val));
+	  PyStructSequence_SET_ITEM(v, i, PyString_FromString(val));
   else {
 	  PyStructSequence_SET_ITEM(v, i, Py_None);
 	  Py_INCREF(Py_None);
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index f85b2ef..01971b7 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -153,7 +153,7 @@
 {
     PyObject *name = hinfo->nameobj;
     if (name == NULL) {
-        name = PyBytes_FromString(hinfo->name);
+        name = PyString_FromString(hinfo->name);
         hinfo->nameobj = name;
     }
     Py_XINCREF(name);
@@ -205,7 +205,7 @@
         Py_INCREF(Py_None);
         return Py_None;
     }
-    return PyBytes_FromString(str);
+    return PyString_FromString(str);
 }
 
 static PyObject *
@@ -218,7 +218,7 @@
         Py_INCREF(Py_None);
         return Py_None;
     }
-    return PyBytes_FromStringAndSize((const char *)str, len);
+    return PyString_FromStringAndSize((const char *)str, len);
 }
 
 /* Callback routines */
@@ -267,16 +267,16 @@
     PyObject *filename = NULL;
 
     if (handler_info[slot].tb_code == NULL) {
-        code = PyBytes_FromString("");
+        code = PyString_FromString("");
         if (code == NULL)
             goto failed;
-        name = PyBytes_FromString(func_name);
+        name = PyString_FromString(func_name);
         if (name == NULL)
             goto failed;
         nulltuple = PyTuple_New(0);
         if (nulltuple == NULL)
             goto failed;
-        filename = PyBytes_FromString(__FILE__);
+        filename = PyString_FromString(__FILE__);
         handler_info[slot].tb_code =
             PyCode_New(0,		/* argcount */
                        0,		/* nlocals */
@@ -971,13 +971,13 @@
         goto finally;
 
     /* XXX what to do if it returns a Unicode string? */
-    if (!PyBytes_Check(str)) {
+    if (!PyString_Check(str)) {
         PyErr_Format(PyExc_TypeError,
                      "read() did not return a string object (type=%.400s)",
                      Py_TYPE(str)->tp_name);
         goto finally;
     }
-    len = PyBytes_GET_SIZE(str);
+    len = PyString_GET_SIZE(str);
     if (len > buf_size) {
         PyErr_Format(PyExc_ValueError,
                      "read() returned too much data: "
@@ -985,7 +985,7 @@
                      buf_size, len);
         goto finally;
     }
-    memcpy(buf, PyBytes_AsString(str), len);
+    memcpy(buf, PyString_AsString(str), len);
 finally:
     Py_XDECREF(arg);
     Py_XDECREF(str);
@@ -1094,7 +1094,7 @@
             = XML_GetInputContext(self->itself, &offset, &size);
 
         if (buffer != NULL)
-            return PyBytes_FromStringAndSize(buffer + offset,
+            return PyString_FromStringAndSize(buffer + offset,
                                               size - offset);
         else
             Py_RETURN_NONE;
@@ -1511,7 +1511,7 @@
 
 #define APPEND(list, str)				\
         do {						\
-                PyObject *o = PyBytes_FromString(str);	\
+                PyObject *o = PyString_FromString(str);	\
                 if (o != NULL)				\
         	        PyList_Append(list, o);		\
                 Py_XDECREF(o);				\
@@ -1862,7 +1862,7 @@
     while (rev[i] != ' ' && rev[i] != '\0')
         ++i;
 
-    return PyBytes_FromStringAndSize(rev, i);
+    return PyString_FromStringAndSize(rev, i);
 }
 
 /* Initialization function for the module */
@@ -1889,7 +1889,7 @@
 MODULE_INITFUNC(void)
 {
     PyObject *m, *d;
-    PyObject *errmod_name = PyBytes_FromString(MODULE_NAME ".errors");
+    PyObject *errmod_name = PyString_FromString(MODULE_NAME ".errors");
     PyObject *errors_module;
     PyObject *modelmod_name;
     PyObject *model_module;
@@ -1899,7 +1899,7 @@
 
     if (errmod_name == NULL)
         return;
-    modelmod_name = PyBytes_FromString(MODULE_NAME ".model");
+    modelmod_name = PyString_FromString(MODULE_NAME ".model");
     if (modelmod_name == NULL)
         return;
 
diff --git a/Modules/readline.c b/Modules/readline.c
index f988d50..90904ab 100644
--- a/Modules/readline.c
+++ b/Modules/readline.c
@@ -421,7 +421,7 @@
 static PyObject *
 get_completer_delims(PyObject *self, PyObject *noarg)
 {
-	return PyBytes_FromString(rl_completer_word_break_characters);
+	return PyString_FromString(rl_completer_word_break_characters);
 }
 
 PyDoc_STRVAR(doc_get_completer_delims,
@@ -471,7 +471,7 @@
 	if (!PyArg_ParseTuple(args, "i:index", &idx))
 		return NULL;
 	if ((hist_ent = history_get(idx)))
-		return PyBytes_FromString(hist_ent->line);
+		return PyString_FromString(hist_ent->line);
 	else {
 		Py_RETURN_NONE;
 	}
@@ -503,7 +503,7 @@
 static PyObject *
 get_line_buffer(PyObject *self, PyObject *noarg)
 {
-	return PyBytes_FromString(rl_line_buffer);
+	return PyString_FromString(rl_line_buffer);
 }
 
 PyDoc_STRVAR(doc_get_line_buffer,
@@ -676,7 +676,7 @@
 	if (m == NULL)
 		goto error;
 	for (i = 0; i < num_matches; i++) {
-		s = PyBytes_FromString(matches[i+1]);
+		s = PyString_FromString(matches[i+1]);
 		if (s == NULL)
 			goto error;
 		if (PyList_SetItem(m, i, s) == -1)
@@ -725,7 +725,7 @@
 			result = NULL;
 		}
 		else {
-			char *s = PyBytes_AsString(r);
+			char *s = PyString_AsString(r);
 			if (s == NULL)
 				goto error;
 			result = strdup(s);
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
index 252332d..83a6538 100644
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -1219,7 +1219,7 @@
 		"data=0x%lx udata=%p>",
 		(unsigned long)(s->e.ident), s->e.filter, s->e.flags,
 		s->e.fflags, (long)(s->e.data), s->e.udata);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static int
diff --git a/Modules/sha256module.c b/Modules/sha256module.c
index d2eefa4..7d56900 100644
--- a/Modules/sha256module.c
+++ b/Modules/sha256module.c
@@ -432,7 +432,7 @@
 
     SHAcopy(self, &temp);
     sha_final(digest, &temp);
-    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+    return PyString_FromStringAndSize((const char *)digest, self->digestsize);
 }
 
 PyDoc_STRVAR(SHA256_hexdigest__doc__,
@@ -452,10 +452,10 @@
     sha_final(digest, &temp);
 
     /* Create a new string */
-    retval = PyBytes_FromStringAndSize(NULL, self->digestsize * 2);
+    retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
     if (!retval)
 	    return NULL;
-    hex_digest = PyBytes_AsString(retval);
+    hex_digest = PyString_AsString(retval);
     if (!hex_digest) {
 	    Py_DECREF(retval);
 	    return NULL;
@@ -510,9 +510,9 @@
 SHA256_get_name(PyObject *self, void *closure)
 {
     if (((SHAobject *)self)->digestsize == 32)
-        return PyBytes_FromStringAndSize("SHA256", 6);
+        return PyString_FromStringAndSize("SHA256", 6);
     else
-        return PyBytes_FromStringAndSize("SHA224", 6);
+        return PyString_FromStringAndSize("SHA224", 6);
 }
 
 static PyGetSetDef SHA_getseters[] = {
diff --git a/Modules/sha512module.c b/Modules/sha512module.c
index 1a2b145..f2c230b 100644
--- a/Modules/sha512module.c
+++ b/Modules/sha512module.c
@@ -498,7 +498,7 @@
 
     SHAcopy(self, &temp);
     sha512_final(digest, &temp);
-    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+    return PyString_FromStringAndSize((const char *)digest, self->digestsize);
 }
 
 PyDoc_STRVAR(SHA512_hexdigest__doc__,
@@ -518,10 +518,10 @@
     sha512_final(digest, &temp);
 
     /* Create a new string */
-    retval = PyBytes_FromStringAndSize(NULL, self->digestsize * 2);
+    retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
     if (!retval)
 	    return NULL;
-    hex_digest = PyBytes_AsString(retval);
+    hex_digest = PyString_AsString(retval);
     if (!hex_digest) {
 	    Py_DECREF(retval);
 	    return NULL;
@@ -576,9 +576,9 @@
 SHA512_get_name(PyObject *self, void *closure)
 {
     if (((SHAobject *)self)->digestsize == 64)
-        return PyBytes_FromStringAndSize("SHA512", 6);
+        return PyString_FromStringAndSize("SHA512", 6);
     else
-        return PyBytes_FromStringAndSize("SHA384", 6);
+        return PyString_FromStringAndSize("SHA384", 6);
 }
 
 static PyGetSetDef SHA_getseters[] = {
diff --git a/Modules/shamodule.c b/Modules/shamodule.c
index 0cb8784..1a7fc2c 100644
--- a/Modules/shamodule.c
+++ b/Modules/shamodule.c
@@ -380,7 +380,7 @@
 
     SHAcopy(self, &temp);
     sha_final(digest, &temp);
-    return PyBytes_FromStringAndSize((const char *)digest, sizeof(digest));
+    return PyString_FromStringAndSize((const char *)digest, sizeof(digest));
 }
 
 PyDoc_STRVAR(SHA_hexdigest__doc__,
@@ -400,10 +400,10 @@
     sha_final(digest, &temp);
 
     /* Create a new string */
-    retval = PyBytes_FromStringAndSize(NULL, sizeof(digest) * 2);
+    retval = PyString_FromStringAndSize(NULL, sizeof(digest) * 2);
     if (!retval)
 	    return NULL;
-    hex_digest = PyBytes_AsString(retval);
+    hex_digest = PyString_AsString(retval);
     if (!hex_digest) {
 	    Py_DECREF(retval);
 	    return NULL;
@@ -463,7 +463,7 @@
 static PyObject *
 SHA_get_name(PyObject *self, void *closure)
 {
-    return PyBytes_FromStringAndSize("SHA1", 4);
+    return PyString_FromStringAndSize("SHA1", 4);
 }
 
 static PyGetSetDef SHA_getseters[] = {
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index fd6b553..e956831 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -911,7 +911,7 @@
 		set_gaierror(error);
 		return NULL;
 	}
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 
@@ -955,7 +955,7 @@
 	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
 		bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
 		bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 #endif
 
@@ -1002,14 +1002,14 @@
 #ifdef linux
 		if (a->sun_path[0] == 0) {  /* Linux abstract namespace */
 			addrlen -= offsetof(struct sockaddr_un, sun_path);
-			return PyBytes_FromStringAndSize(a->sun_path,
+			return PyString_FromStringAndSize(a->sun_path,
 							  addrlen);
 		}
 		else
 #endif /* linux */
 		{
 			/* regular NULL-terminated string */
-			return PyBytes_FromString(a->sun_path);
+			return PyString_FromString(a->sun_path);
 		}
 	}
 #endif /* AF_UNIX */
@@ -1362,7 +1362,7 @@
 
 			addr = (struct sockaddr_sco *)addr_ret;
 			_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
-			straddr = PyBytes_AsString(args);
+			straddr = PyString_AsString(args);
 			if (straddr == NULL) {
 				PyErr_SetString(socket_error, "getsockaddrarg: "
 						"wrong format");
@@ -1854,16 +1854,16 @@
 				"getsockopt buflen out of range");
 		return NULL;
 	}
-	buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
+	buf = PyString_FromStringAndSize((char *)NULL, buflen);
 	if (buf == NULL)
 		return NULL;
 	res = getsockopt(s->sock_fd, level, optname,
-			 (void *)PyBytes_AS_STRING(buf), &buflen);
+			 (void *)PyString_AS_STRING(buf), &buflen);
 	if (res < 0) {
 		Py_DECREF(buf);
 		return s->errorhandler();
 	}
-	_PyBytes_Resize(&buf, buflen);
+	_PyString_Resize(&buf, buflen);
 	return buf;
 #endif /* __BEOS__ */
 }
@@ -2386,12 +2386,12 @@
 	}
 
 	/* Allocate a new string. */
-	buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+	buf = PyString_FromStringAndSize((char *) 0, recvlen);
 	if (buf == NULL)
 		return NULL;
 
 	/* Call the guts */
-	outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
+	outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags);
 	if (outlen < 0) {
 		/* An error occurred, release the string and return an
 		   error. */
@@ -2401,7 +2401,7 @@
 	if (outlen != recvlen) {
 		/* We did not read as many bytes as we anticipated, resize the
 		   string if possible and be succesful. */
-		if (_PyBytes_Resize(&buf, outlen) < 0)
+		if (_PyString_Resize(&buf, outlen) < 0)
 			/* Oopsy, not so succesful after all. */
 			return NULL;
 	}
@@ -2560,11 +2560,11 @@
 		return NULL;
 	}
 
-	buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+	buf = PyString_FromStringAndSize((char *) 0, recvlen);
 	if (buf == NULL)
 		return NULL;
 
-	outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
+	outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf),
 				    recvlen, flags, &addr);
 	if (outlen < 0) {
 		goto finally;
@@ -2573,7 +2573,7 @@
 	if (outlen != recvlen) {
 		/* We did not read as many bytes as we anticipated, resize the
 		   string if possible and be succesful. */
-		if (_PyBytes_Resize(&buf, outlen) < 0)
+		if (_PyString_Resize(&buf, outlen) < 0)
 			/* Oopsy, not so succesful after all. */
 			goto finally;
 	}
@@ -2941,7 +2941,7 @@
 		(long)s->sock_fd, s->sock_family,
 		s->sock_type,
 		s->sock_proto);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 
@@ -3057,7 +3057,7 @@
 	if (res < 0)
 		return set_error();
 	buf[sizeof buf - 1] = '\0';
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 PyDoc_STRVAR(gethostname_doc,
@@ -3143,7 +3143,7 @@
 	if (h->h_aliases) {
 		for (pch = h->h_aliases; *pch != NULL; pch++) {
 			int status;
-			tmp = PyBytes_FromString(*pch);
+			tmp = PyString_FromString(*pch);
 			if (tmp == NULL)
 				goto err;
 
@@ -3432,7 +3432,7 @@
 		PyErr_SetString(socket_error, "port/proto not found");
 		return NULL;
 	}
-	return PyBytes_FromString(sp->s_name);
+	return PyString_FromString(sp->s_name);
 }
 
 PyDoc_STRVAR(getservbyport_doc,
@@ -3734,7 +3734,7 @@
     if (inet_aton != NULL) {
 #endif
 	if (inet_aton(ip_addr, &buf))
-		return PyBytes_FromStringAndSize((char *)(&buf),
+		return PyString_FromStringAndSize((char *)(&buf),
 						  sizeof(buf));
 
 	PyErr_SetString(socket_error,
@@ -3763,7 +3763,7 @@
 			return NULL;
 		}
 	}
-	return PyBytes_FromStringAndSize((char *) &packed_addr,
+	return PyString_FromStringAndSize((char *) &packed_addr,
 					  sizeof(packed_addr));
 
 #ifdef USE_INET_ATON_WEAKLINK
@@ -3797,7 +3797,7 @@
 
 	memcpy(&packed_addr, packed_str, addr_len);
 
-	return PyBytes_FromString(inet_ntoa(packed_addr));
+	return PyString_FromString(inet_ntoa(packed_addr));
 }
 
 #ifdef HAVE_INET_PTON
@@ -3840,11 +3840,11 @@
 			"illegal IP address string passed to inet_pton");
 		return NULL;
 	} else if (af == AF_INET) {
-		return PyBytes_FromStringAndSize(packed,
+		return PyString_FromStringAndSize(packed,
 			sizeof(struct in_addr));
 #ifdef ENABLE_IPV6
 	} else if (af == AF_INET6) {
-		return PyBytes_FromStringAndSize(packed,
+		return PyString_FromStringAndSize(packed,
 			sizeof(struct in6_addr));
 #endif
 	} else {
@@ -3871,7 +3871,7 @@
 	char ip[INET_ADDRSTRLEN + 1];
 #endif
 
-	/* Guarantee NUL-termination for PyBytes_FromString() below */
+	/* Guarantee NUL-termination for PyString_FromString() below */
 	memset((void *) &ip[0], '\0', sizeof(ip));
 
 	if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {
@@ -3903,7 +3903,7 @@
 		PyErr_SetFromErrno(socket_error);
 		return NULL;
 	} else {
-		return PyBytes_FromString(retval);
+		return PyString_FromString(retval);
 	}
 
 	/* NOTREACHED */
@@ -3944,9 +3944,9 @@
 		idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
 		if (!idna)
 			return NULL;
-		hptr = PyBytes_AsString(idna);
-	} else if (PyBytes_Check(hobj)) {
-		hptr = PyBytes_AsString(hobj);
+		hptr = PyString_AsString(idna);
+	} else if (PyString_Check(hobj)) {
+		hptr = PyString_AsString(hobj);
 	} else {
 		PyErr_SetString(PyExc_TypeError,
 				"getaddrinfo() argument 1 must be string or None");
@@ -3955,8 +3955,8 @@
 	if (PyInt_Check(pobj)) {
 		PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
 		pptr = pbuf;
-	} else if (PyBytes_Check(pobj)) {
-		pptr = PyBytes_AsString(pobj);
+	} else if (PyString_Check(pobj)) {
+		pptr = PyString_AsString(pobj);
 	} else if (pobj == Py_None) {
 		pptr = (char *)NULL;
 	} else {
diff --git a/Modules/spwdmodule.c b/Modules/spwdmodule.c
index 221223e..d3f309a 100644
--- a/Modules/spwdmodule.c
+++ b/Modules/spwdmodule.c
@@ -60,7 +60,7 @@
 sets(PyObject *v, int i, char* val)
 {
   if (val)
-	  PyStructSequence_SET_ITEM(v, i, PyBytes_FromString(val));
+	  PyStructSequence_SET_ITEM(v, i, PyString_FromString(val));
   else {
 	  PyStructSequence_SET_ITEM(v, i, Py_None);
 	  Py_INCREF(Py_None);
diff --git a/Modules/stropmodule.c b/Modules/stropmodule.c
index e0e5ad0..8b00fed 100644
--- a/Modules/stropmodule.c
+++ b/Modules/stropmodule.c
@@ -47,7 +47,7 @@
 			i = i+1;
 		}
 		if (j < i) {
-			item = PyBytes_FromStringAndSize(s+j, i-j);
+			item = PyString_FromStringAndSize(s+j, i-j);
 			if (item == NULL)
 				goto finally;
 
@@ -61,7 +61,7 @@
 				i = i+1;
 			}
 			if (maxsplit && (countsplit >= maxsplit) && i < len) {
-				item = PyBytes_FromStringAndSize(
+				item = PyString_FromStringAndSize(
                                         s+i, len - i);
 				if (item == NULL)
 					goto finally;
@@ -122,7 +122,7 @@
 	i = j = 0;
 	while (i+n <= len) {
 		if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
-			item = PyBytes_FromStringAndSize(s+j, i-j);
+			item = PyString_FromStringAndSize(s+j, i-j);
 			if (item == NULL)
 				goto fail;
 			err = PyList_Append(list, item);
@@ -137,7 +137,7 @@
 		else
 			i++;
 	}
-	item = PyBytes_FromStringAndSize(s+j, len-j);
+	item = PyString_FromStringAndSize(s+j, len-j);
 	if (item == NULL)
 		goto fail;
 	err = PyList_Append(list, item);
@@ -189,7 +189,7 @@
 	if (seqlen == 1) {
 		/* Optimization if there's only one item */
 		PyObject *item = PySequence_GetItem(seq, 0);
-		if (item && !PyBytes_Check(item)) {
+		if (item && !PyString_Check(item)) {
 			PyErr_SetString(PyExc_TypeError,
 				 "first argument must be sequence of strings");
 			Py_DECREF(item);
@@ -198,9 +198,9 @@
 		return item;
 	}
 
-	if (!(res = PyBytes_FromStringAndSize((char*)NULL, sz)))
+	if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
 		return NULL;
-	p = PyBytes_AsString(res);
+	p = PyString_AsString(res);
 
 	/* optimize for lists, since it's the most common case.  all others
 	 * (tuples and arbitrary sequences) just use the sequence abstract
@@ -209,29 +209,29 @@
 	if (PyList_Check(seq)) {
 		for (i = 0; i < seqlen; i++) {
 			PyObject *item = PyList_GET_ITEM(seq, i);
-			if (!PyBytes_Check(item)) {
+			if (!PyString_Check(item)) {
 				PyErr_SetString(PyExc_TypeError,
 				"first argument must be sequence of strings");
 				Py_DECREF(res);
 				return NULL;
 			}
-			slen = PyBytes_GET_SIZE(item);
+			slen = PyString_GET_SIZE(item);
 			while (reslen + slen + seplen >= sz) {
-				if (_PyBytes_Resize(&res, sz * 2) < 0)
+				if (_PyString_Resize(&res, sz * 2) < 0)
 					return NULL;
 				sz *= 2;
-				p = PyBytes_AsString(res) + reslen;
+				p = PyString_AsString(res) + reslen;
 			}
 			if (i > 0) {
 				memcpy(p, sep, seplen);
 				p += seplen;
 				reslen += seplen;
 			}
-			memcpy(p, PyBytes_AS_STRING(item), slen);
+			memcpy(p, PyString_AS_STRING(item), slen);
 			p += slen;
 			reslen += slen;
 		}
-		_PyBytes_Resize(&res, reslen);
+		_PyString_Resize(&res, reslen);
 		return res;
 	}
 
@@ -245,33 +245,33 @@
 	/* This is now type safe */
 	for (i = 0; i < seqlen; i++) {
 		PyObject *item = getitemfunc(seq, i);
-		if (!item || !PyBytes_Check(item)) {
+		if (!item || !PyString_Check(item)) {
 			PyErr_SetString(PyExc_TypeError,
 				 "first argument must be sequence of strings");
 			Py_DECREF(res);
 			Py_XDECREF(item);
 			return NULL;
 		}
-		slen = PyBytes_GET_SIZE(item);
+		slen = PyString_GET_SIZE(item);
 		while (reslen + slen + seplen >= sz) {
-			if (_PyBytes_Resize(&res, sz * 2) < 0) {
+			if (_PyString_Resize(&res, sz * 2) < 0) {
 				Py_DECREF(item);
 				return NULL;
 			}
 			sz *= 2;
-			p = PyBytes_AsString(res) + reslen;
+			p = PyString_AsString(res) + reslen;
 		}
 		if (i > 0) {
 			memcpy(p, sep, seplen);
 			p += seplen;
 			reslen += seplen;
 		}
-		memcpy(p, PyBytes_AS_STRING(item), slen);
+		memcpy(p, PyString_AS_STRING(item), slen);
 		p += slen;
 		reslen += slen;
 		Py_DECREF(item);
 	}
-	_PyBytes_Resize(&res, reslen);
+	_PyString_Resize(&res, reslen);
 	return res;
 }
 
@@ -369,7 +369,7 @@
 	Py_ssize_t len, i, j;
 
 
-	if (PyBytes_AsStringAndSize(args, &s, &len))
+	if (PyString_AsStringAndSize(args, &s, &len))
 		return NULL;
 
 	i = 0;
@@ -392,7 +392,7 @@
 		return args;
 	}
 	else
-		return PyBytes_FromStringAndSize(s+i, j-i);
+		return PyString_FromStringAndSize(s+i, j-i);
 }
 
 
@@ -450,12 +450,12 @@
 	int changed;
 
 	WARN;
-	if (PyBytes_AsStringAndSize(args, &s, &n))
+	if (PyString_AsStringAndSize(args, &s, &n))
 		return NULL;
-	newstr = PyBytes_FromStringAndSize(NULL, n);
+	newstr = PyString_FromStringAndSize(NULL, n);
 	if (newstr == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newstr);
+	s_new = PyString_AsString(newstr);
 	changed = 0;
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(*s++);
@@ -489,12 +489,12 @@
 	int changed;
 
 	WARN;
-	if (PyBytes_AsStringAndSize(args, &s, &n))
+	if (PyString_AsStringAndSize(args, &s, &n))
 		return NULL;
-	newstr = PyBytes_FromStringAndSize(NULL, n);
+	newstr = PyString_FromStringAndSize(NULL, n);
 	if (newstr == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newstr);
+	s_new = PyString_AsString(newstr);
 	changed = 0;
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(*s++);
@@ -529,12 +529,12 @@
 	int changed;
 
 	WARN;
-	if (PyBytes_AsStringAndSize(args, &s, &n))
+	if (PyString_AsStringAndSize(args, &s, &n))
 		return NULL;
-	newstr = PyBytes_FromStringAndSize(NULL, n);
+	newstr = PyString_FromStringAndSize(NULL, n);
 	if (newstr == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newstr);
+	s_new = PyString_AsString(newstr);
 	changed = 0;
 	if (0 < n) {
 		int c = Py_CHARMASK(*s++);
@@ -610,12 +610,12 @@
 	}
 
 	/* Second pass: create output string and fill it */
-	out = PyBytes_FromStringAndSize(NULL, i+j);
+	out = PyString_FromStringAndSize(NULL, i+j);
 	if (out == NULL)
 		return NULL;
 
 	i = 0;
-	q = PyBytes_AS_STRING(out);
+	q = PyString_AS_STRING(out);
 
 	for (p = string; p < e; p++) {
 		if (*p == '\t') {
@@ -695,12 +695,12 @@
 	int changed;
 
 	WARN;
-	if (PyBytes_AsStringAndSize(args, &s, &n))
+	if (PyString_AsStringAndSize(args, &s, &n))
 		return NULL;
-	newstr = PyBytes_FromStringAndSize(NULL, n);
+	newstr = PyString_FromStringAndSize(NULL, n);
 	if (newstr == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newstr);
+	s_new = PyString_AsString(newstr);
 	changed = 0;
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(*s++);
@@ -898,10 +898,10 @@
 		return NULL;
 	}
 
-	result = PyBytes_FromStringAndSize((char *)NULL, 256);
+	result = PyString_FromStringAndSize((char *)NULL, 256);
 	if (result == NULL)
 		return NULL;
-	c = (unsigned char *) PyBytes_AS_STRING((PyBytesObject *)result);
+	c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
 	for (i = 0; i < 256; i++)
 		c[i]=(unsigned char)i;
 	for (i = 0; i < fromlen; i++)
@@ -942,12 +942,12 @@
 	}
 
 	table = table1;
-	inlen = PyBytes_GET_SIZE(input_obj);
-	result = PyBytes_FromStringAndSize((char *)NULL, inlen);
+	inlen = PyString_GET_SIZE(input_obj);
+	result = PyString_FromStringAndSize((char *)NULL, inlen);
 	if (result == NULL)
 		return NULL;
-	output_start = output = PyBytes_AsString(result);
-	input = PyBytes_AsString(input_obj);
+	output_start = output = PyString_AsString(result);
+	input = PyString_AsString(input_obj);
 
 	if (dellen == 0) {
 		/* If no deletions are required, use faster code */
@@ -983,7 +983,7 @@
 	}
 	/* Fix the size of the resulting string */
 	if (inlen > 0)
-		_PyBytes_Resize(&result, output - output_start);
+		_PyString_Resize(&result, output - output_start);
 	return result;
 }
 
@@ -1169,7 +1169,7 @@
 		Py_XINCREF(newstr);
 	}
 	else {
-		newstr = PyBytes_FromStringAndSize(new_s, out_len);
+		newstr = PyString_FromStringAndSize(new_s, out_len);
 		PyMem_FREE(new_s);
 	}
 	return newstr;
@@ -1222,7 +1222,7 @@
 		if (isspace(c))
 			buf[n++] = c;
 	}
-	s = PyBytes_FromStringAndSize(buf, n);
+	s = PyString_FromStringAndSize(buf, n);
 	if (s)
 		PyModule_AddObject(m, "whitespace", s);
 
@@ -1232,7 +1232,7 @@
 		if (islower(c))
 			buf[n++] = c;
 	}
-	s = PyBytes_FromStringAndSize(buf, n);
+	s = PyString_FromStringAndSize(buf, n);
 	if (s)
 		PyModule_AddObject(m, "lowercase", s);
 
@@ -1242,7 +1242,7 @@
 		if (isupper(c))
 			buf[n++] = c;
 	}
-	s = PyBytes_FromStringAndSize(buf, n);
+	s = PyString_FromStringAndSize(buf, n);
 	if (s)
 		PyModule_AddObject(m, "uppercase", s);
 }
diff --git a/Modules/sunaudiodev.c b/Modules/sunaudiodev.c
index f4b430e..285dc66 100644
--- a/Modules/sunaudiodev.c
+++ b/Modules/sunaudiodev.c
@@ -135,11 +135,11 @@
 	
         if (!PyArg_ParseTuple(args, "i:read", &size))
 		return NULL;
-	rv = PyBytes_FromStringAndSize(NULL, size);
+	rv = PyString_FromStringAndSize(NULL, size);
 	if (rv == NULL)
 		return NULL;
 
-	if (!(cp = PyBytes_AsString(rv)))
+	if (!(cp = PyString_AsString(rv)))
 		goto finally;
 
 	count = read(self->x_fd, cp, size);
diff --git a/Modules/svmodule.c b/Modules/svmodule.c
index 485259f..3845e20 100644
--- a/Modules/svmodule.c
+++ b/Modules/svmodule.c
@@ -47,13 +47,13 @@
 	if (!PyArg_Parse(args, "i", &invert))
 		return NULL;
 
-	if (!(output = PyBytes_FromStringAndSize(
+	if (!(output = PyString_FromStringAndSize(
 		NULL,
 		(int)(self->ob_info.width * self->ob_info.height * factor))))
 	{
 		return NULL;
 	}
-	if (!(outstr = PyBytes_AsString(output))) {
+	if (!(outstr = PyString_AsString(output))) {
 		Py_DECREF(output);
 		return NULL;
 	}
@@ -152,9 +152,9 @@
 	fieldsize = self->ob_info.width * self->ob_info.height / 2;
 	obcapture = (char*)self->ob_capture;
 	
-	if (!(f1 = PyBytes_FromStringAndSize(obcapture, fieldsize)))
+	if (!(f1 = PyString_FromStringAndSize(obcapture, fieldsize)))
 		goto finally;
-	if (!(f2 = PyBytes_FromStringAndSize(obcapture + fieldsize,
+	if (!(f2 = PyString_FromStringAndSize(obcapture + fieldsize,
 					      fieldsize)))
 		goto finally;
 	ret = PyTuple_Pack(2, f1, f2);
@@ -535,12 +535,12 @@
 		goto finally;
 	}
 
-	if (!(videodata = PyBytes_FromStringAndSize(NULL, bytes)))
+	if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
 		goto finally;
 
 	/* XXX -- need to do something about the bitvector */
 	{
-		char* str = PyBytes_AsString(videodata);
+		char* str = PyString_AsString(videodata);
 		if (!str)
 			goto finally;
 		
@@ -615,10 +615,10 @@
 	if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
 		return sv_error();
 
-	if (!(videodata = PyBytes_FromStringAndSize(NULL, bytes)))
+	if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
 		return NULL;
 	
-	str = PyBytes_AsString(videodata);
+	str = PyString_AsString(videodata);
 	if (!str)
 		goto finally;
 
@@ -849,11 +849,11 @@
 		return NULL;
 	}
 
-	if (!(output = PyBytes_FromStringAndSize(NULL,
+	if (!(output = PyString_FromStringAndSize(NULL,
 					      (int)(width * height * factor))))
 		return NULL;
 
-	str = PyBytes_AsString(output);
+	str = PyString_AsString(output);
 	if (!str) {
 		Py_DECREF(output);
 		return NULL;
diff --git a/Modules/syslogmodule.c b/Modules/syslogmodule.c
index a515a17..9e1ed06 100644
--- a/Modules/syslogmodule.c
+++ b/Modules/syslogmodule.c
@@ -71,7 +71,7 @@
 	S_ident_o = new_S_ident_o;
 	Py_INCREF(S_ident_o);
 
-	openlog(PyBytes_AsString(S_ident_o), logopt, facility);
+	openlog(PyString_AsString(S_ident_o), logopt, facility);
 
 	Py_INCREF(Py_None);
 	return Py_None;
diff --git a/Modules/termios.c b/Modules/termios.c
index c6d05ce..c53566c 100644
--- a/Modules/termios.c
+++ b/Modules/termios.c
@@ -91,7 +91,7 @@
 		return NULL;
 	for (i = 0; i < NCCS; i++) {
 		ch = (char)mode.c_cc[i];
-		v = PyBytes_FromStringAndSize(&ch, 1);
+		v = PyString_FromStringAndSize(&ch, 1);
 		if (v == NULL)
 			goto err;
 		PyList_SetItem(cc, i, v);
@@ -183,8 +183,8 @@
 	for (i = 0; i < NCCS; i++) {
 		v = PyList_GetItem(cc, i);
 
-		if (PyBytes_Check(v) && PyBytes_Size(v) == 1)
-			mode.c_cc[i] = (cc_t) * PyBytes_AsString(v);
+		if (PyString_Check(v) && PyString_Size(v) == 1)
+			mode.c_cc[i] = (cc_t) * PyString_AsString(v);
 		else if (PyInt_Check(v))
 			mode.c_cc[i] = (cc_t) PyInt_AsLong(v);
 		else {
diff --git a/Modules/threadmodule.c b/Modules/threadmodule.c
index 7b52f72..81bf288 100644
--- a/Modules/threadmodule.c
+++ b/Modules/threadmodule.c
@@ -190,7 +190,7 @@
 	Py_XINCREF(kw);
 	self->kw = kw;
 	self->dict = NULL;	/* making sure */
-	self->key = PyBytes_FromFormat("thread.local.%p", self);
+	self->key = PyString_FromFormat("thread.local.%p", self);
 	if (self->key == NULL) 
 		goto err;
 
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 92c47cb..c6f68f8 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -488,7 +488,7 @@
 			   e.g. an empty format, or %Z when the timezone
 			   is unknown. */
 			PyObject *ret;
-			ret = PyBytes_FromStringAndSize(outbuf, buflen);
+			ret = PyString_FromStringAndSize(outbuf, buflen);
 			free(outbuf);
 			return ret;
 		}
@@ -548,7 +548,7 @@
 	p = asctime(&buf);
 	if (p[24] == '\n')
 		p[24] = '\0';
-	return PyBytes_FromString(p);
+	return PyString_FromString(p);
 }
 
 PyDoc_STRVAR(asctime_doc,
@@ -584,7 +584,7 @@
 	}
 	if (p[24] == '\n')
 		p[24] = '\0';
-	return PyBytes_FromString(p);
+	return PyString_FromString(p);
 }
 
 PyDoc_STRVAR(ctime_doc,
diff --git a/Modules/unicodedata.c b/Modules/unicodedata.c
index 8ce280f..abb391a 100644
--- a/Modules/unicodedata.c
+++ b/Modules/unicodedata.c
@@ -266,7 +266,7 @@
         if (old->category_changed != 0xFF)
             index = old->category_changed;
     }
-    return PyBytes_FromString(_PyUnicode_CategoryNames[index]);
+    return PyString_FromString(_PyUnicode_CategoryNames[index]);
 }
 
 PyDoc_STRVAR(unicodedata_bidirectional__doc__,
@@ -297,7 +297,7 @@
         else if (old->bidir_changed != 0xFF)
             index = old->bidir_changed;
     }
-    return PyBytes_FromString(_PyUnicode_BidirectionalNames[index]);
+    return PyString_FromString(_PyUnicode_BidirectionalNames[index]);
 }
 
 PyDoc_STRVAR(unicodedata_combining__doc__,
@@ -383,7 +383,7 @@
         if (old->category_changed == 0)
             index = 0; /* unassigned */
     }
-    return PyBytes_FromString(_PyUnicode_EastAsianWidthNames[index]);
+    return PyString_FromString(_PyUnicode_EastAsianWidthNames[index]);
 }
 
 PyDoc_STRVAR(unicodedata_decomposition__doc__,
@@ -414,7 +414,7 @@
     if (self) {
         const change_record *old = get_old_record(self, c);
         if (old->category_changed == 0)
-            return PyBytes_FromString(""); /* unassigned */
+            return PyString_FromString(""); /* unassigned */
     }
 
     if (code < 0 || code >= 0x110000)
@@ -453,7 +453,7 @@
     
     decomp[i] = '\0';
 
-    return PyBytes_FromString(decomp);
+    return PyString_FromString(decomp);
 }
 
 static void
@@ -518,7 +518,7 @@
             /* Hangul Decomposition adds three characters in
                a single step, so we need atleast that much room. */
             if (space < 3) {
-                Py_ssize_t newsize = PyBytes_GET_SIZE(result) + 10;
+                Py_ssize_t newsize = PyString_GET_SIZE(result) + 10;
                 space += 10;
                 if (PyUnicode_Resize(&result, newsize) == -1)
                     return NULL;
diff --git a/Modules/zipimport.c b/Modules/zipimport.c
index bd13487..d3cd4ad 100644
--- a/Modules/zipimport.c
+++ b/Modules/zipimport.c
@@ -154,11 +154,11 @@
 		}
 	}
 
-	self->archive = PyBytes_FromString(buf);
+	self->archive = PyString_FromString(buf);
 	if (self->archive == NULL)
 		return -1;
 
-	self->prefix = PyBytes_FromString(prefix);
+	self->prefix = PyString_FromString(prefix);
 	if (self->prefix == NULL)
 		return -1;
 
@@ -191,10 +191,10 @@
 	char *archive = "???";
 	char *prefix = "";
 
-	if (self->archive != NULL && PyBytes_Check(self->archive))
-		archive = PyBytes_AsString(self->archive);
-	if (self->prefix != NULL && PyBytes_Check(self->prefix))
-		prefix = PyBytes_AsString(self->prefix);
+	if (self->archive != NULL && PyString_Check(self->archive))
+		archive = PyString_AsString(self->archive);
+	if (self->prefix != NULL && PyString_Check(self->prefix))
+		prefix = PyString_AsString(self->prefix);
 	if (prefix != NULL && *prefix)
 		PyOS_snprintf(buf, sizeof(buf),
 			      "<zipimporter object \"%.300s%c%.150s\">",
@@ -203,7 +203,7 @@
 		PyOS_snprintf(buf, sizeof(buf),
 			      "<zipimporter object \"%.300s\">",
 			      archive);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 /* return fullname.split(".")[-1] */
@@ -263,7 +263,7 @@
 
 	subname = get_subname(fullname);
 
-	len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+	len = make_filename(PyString_AsString(self->prefix), subname, path);
 	if (len < 0)
 		return MI_ERROR;
 
@@ -336,12 +336,12 @@
 		/* add __path__ to the module *before* the code gets
 		   executed */
 		PyObject *pkgpath, *fullpath;
-		char *prefix = PyBytes_AsString(self->prefix);
+		char *prefix = PyString_AsString(self->prefix);
 		char *subname = get_subname(fullname);
 		int err;
 
-		fullpath = PyBytes_FromFormat("%s%c%s%s",
-					PyBytes_AsString(self->archive),
+		fullpath = PyString_FromFormat("%s%c%s%s",
+					PyString_AsString(self->archive),
 					SEP,
 					*prefix ? prefix : "",
 					subname);
@@ -418,9 +418,9 @@
 	}
 	path = buf;
 #endif
-	len = PyBytes_Size(self->archive);
+	len = PyString_Size(self->archive);
 	if ((size_t)len < strlen(path) &&
-	    strncmp(path, PyBytes_AsString(self->archive), len) == 0 &&
+	    strncmp(path, PyString_AsString(self->archive), len) == 0 &&
 	    path[len] == SEP) {
 		path = path + len + 1;
 	}
@@ -430,7 +430,7 @@
 		PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
 		return NULL;
 	}
-	return get_data(PyBytes_AsString(self->archive), toc_entry);
+	return get_data(PyString_AsString(self->archive), toc_entry);
 }
 
 static PyObject *
@@ -467,7 +467,7 @@
 	}
 	subname = get_subname(fullname);
 
-	len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+	len = make_filename(PyString_AsString(self->prefix), subname, path);
 	if (len < 0)
 		return NULL;
 
@@ -480,7 +480,7 @@
 
 	toc_entry = PyDict_GetItemString(self->files, path);
 	if (toc_entry != NULL)
-		return get_data(PyBytes_AsString(self->archive), toc_entry);
+		return get_data(PyString_AsString(self->archive), toc_entry);
 
 	/* we have the module, but no source */
 	Py_INCREF(Py_None);
@@ -843,13 +843,13 @@
 	    PyMarshal_ReadShortFromFile(fp);	/* local header size */
 	file_offset += l;	/* Start of file data */
 
-	raw_data = PyBytes_FromStringAndSize((char *)NULL, compress == 0 ?
+	raw_data = PyString_FromStringAndSize((char *)NULL, compress == 0 ?
 					      data_size : data_size + 1);
 	if (raw_data == NULL) {
 		fclose(fp);
 		return NULL;
 	}
-	buf = PyBytes_AsString(raw_data);
+	buf = PyString_AsString(raw_data);
 
 	err = fseek(fp, file_offset, 0);
 	if (err == 0)
@@ -907,8 +907,8 @@
 unmarshal_code(char *pathname, PyObject *data, time_t mtime)
 {
 	PyObject *code;
-	char *buf = PyBytes_AsString(data);
-	Py_ssize_t size = PyBytes_Size(data);
+	char *buf = PyString_AsString(data);
+	Py_ssize_t size = PyString_Size(data);
 
 	if (size <= 9) {
 		PyErr_SetString(ZipImportError,
@@ -953,14 +953,14 @@
 static PyObject *
 normalize_line_endings(PyObject *source)
 {
-	char *buf, *q, *p = PyBytes_AsString(source);
+	char *buf, *q, *p = PyString_AsString(source);
 	PyObject *fixed_source;
 
 	if (!p)
 		return NULL;
 
 	/* one char extra for trailing \n and one for terminating \0 */
-	buf = (char *)PyMem_Malloc(PyBytes_Size(source) + 2);
+	buf = (char *)PyMem_Malloc(PyString_Size(source) + 2);
 	if (buf == NULL) {
 		PyErr_SetString(PyExc_MemoryError,
 				"zipimport: no memory to allocate "
@@ -979,7 +979,7 @@
 	}
 	*q++ = '\n';  /* add trailing \n */
 	*q = '\0';
-	fixed_source = PyBytes_FromString(buf);
+	fixed_source = PyString_FromString(buf);
 	PyMem_Free(buf);
 	return fixed_source;
 }
@@ -995,7 +995,7 @@
 	if (fixed_source == NULL)
 		return NULL;
 
-	code = Py_CompileString(PyBytes_AsString(fixed_source), pathname,
+	code = Py_CompileString(PyString_AsString(fixed_source), pathname,
 				Py_file_input);
 	Py_DECREF(fixed_source);
 	return code;
@@ -1054,7 +1054,7 @@
 {
 	PyObject *data, *code;
 	char *modpath;
-	char *archive = PyBytes_AsString(self->archive);
+	char *archive = PyString_AsString(self->archive);
 
 	if (archive == NULL)
 		return NULL;
@@ -1063,7 +1063,7 @@
 	if (data == NULL)
 		return NULL;
 
-	modpath = PyBytes_AsString(PyTuple_GetItem(toc_entry, 0));
+	modpath = PyString_AsString(PyTuple_GetItem(toc_entry, 0));
 
 	if (isbytecode) {
 		code = unmarshal_code(modpath, data, mtime);
@@ -1088,7 +1088,7 @@
 
 	subname = get_subname(fullname);
 
-	len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+	len = make_filename(PyString_AsString(self->prefix), subname, path);
 	if (len < 0)
 		return NULL;
 
@@ -1098,7 +1098,7 @@
 		strcpy(path + len, zso->suffix);
 		if (Py_VerboseFlag > 1)
 			PySys_WriteStderr("# trying %s%c%s\n",
-					  PyBytes_AsString(self->archive),
+					  PyString_AsString(self->archive),
 					  SEP, path);
 		toc_entry = PyDict_GetItemString(self->files, path);
 		if (toc_entry != NULL) {
@@ -1120,7 +1120,7 @@
 				continue;
 			}
 			if (code != NULL && p_modpath != NULL)
-				*p_modpath = PyBytes_AsString(
+				*p_modpath = PyString_AsString(
 					PyTuple_GetItem(toc_entry, 0));
 			return code;
 		}
diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c
index 590ab5f..4f78dbc 100644
--- a/Modules/zlibmodule.c
+++ b/Modules/zlibmodule.c
@@ -96,12 +96,12 @@
     if (self == NULL)
 	return NULL;
     self->is_initialised = 0;
-    self->unused_data = PyBytes_FromString("");
+    self->unused_data = PyString_FromString("");
     if (self->unused_data == NULL) {
 	Py_DECREF(self);
 	return NULL;
     }
-    self->unconsumed_tail = PyBytes_FromString("");
+    self->unconsumed_tail = PyString_FromString("");
     if (self->unconsumed_tail == NULL) {
 	Py_DECREF(self);
 	return NULL;
@@ -174,7 +174,7 @@
 
     err=deflateEnd(&zst);
     if (err == Z_OK)
-	ReturnVal = PyBytes_FromStringAndSize((char *)output,
+	ReturnVal = PyString_FromStringAndSize((char *)output,
 					       zst.total_out);
     else
 	zlib_error(zst, err, "while finishing compression");
@@ -211,12 +211,12 @@
     zst.avail_in = length;
     zst.avail_out = r_strlen;
 
-    if (!(result_str = PyBytes_FromStringAndSize(NULL, r_strlen)))
+    if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
 	return NULL;
 
     zst.zalloc = (alloc_func)NULL;
     zst.zfree = (free_func)Z_NULL;
-    zst.next_out = (Byte *)PyBytes_AS_STRING(result_str);
+    zst.next_out = (Byte *)PyString_AS_STRING(result_str);
     zst.next_in = (Byte *)input;
     err = inflateInit2(&zst, wsize);
 
@@ -256,11 +256,11 @@
 	    /* fall through */
 	case(Z_OK):
 	    /* need more memory */
-	    if (_PyBytes_Resize(&result_str, r_strlen << 1) < 0) {
+	    if (_PyString_Resize(&result_str, r_strlen << 1) < 0) {
 		inflateEnd(&zst);
 		goto error;
 	    }
-	    zst.next_out = (unsigned char *)PyBytes_AS_STRING(result_str) \
+	    zst.next_out = (unsigned char *)PyString_AS_STRING(result_str) \
 		+ r_strlen;
 	    zst.avail_out = r_strlen;
 	    r_strlen = r_strlen << 1;
@@ -278,7 +278,7 @@
 	goto error;
     }
 
-    _PyBytes_Resize(&result_str, zst.total_out);
+    _PyString_Resize(&result_str, zst.total_out);
     return result_str;
 
  error:
@@ -400,7 +400,7 @@
     if (!PyArg_ParseTuple(args, "s#:compress", &input, &inplen))
 	return NULL;
 
-    if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+    if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 	return NULL;
 
     ENTER_ZLIB
@@ -409,7 +409,7 @@
     self->zst.avail_in = inplen;
     self->zst.next_in = input;
     self->zst.avail_out = length;
-    self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+    self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 
     Py_BEGIN_ALLOW_THREADS
     err = deflate(&(self->zst), Z_NO_FLUSH);
@@ -418,9 +418,9 @@
     /* while Z_OK and the output buffer is full, there might be more output,
        so extend the output buffer and try again */
     while (err == Z_OK && self->zst.avail_out == 0) {
-	if (_PyBytes_Resize(&RetVal, length << 1) < 0)
+	if (_PyString_Resize(&RetVal, length << 1) < 0)
 	    goto error;
-	self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+	self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 	    + length;
 	self->zst.avail_out = length;
 	length = length << 1;
@@ -440,7 +440,7 @@
 	RetVal = NULL;
 	goto error;
     }
-    _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+    _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 
  error:
     LEAVE_ZLIB
@@ -479,7 +479,7 @@
     /* limit amount of data allocated to max_length */
     if (max_length && length > max_length)
 	length = max_length;
-    if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+    if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 	return NULL;
 
     ENTER_ZLIB
@@ -488,7 +488,7 @@
     self->zst.avail_in = inplen;
     self->zst.next_in = input;
     self->zst.avail_out = length;
-    self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+    self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 
     Py_BEGIN_ALLOW_THREADS
     err = inflate(&(self->zst), Z_SYNC_FLUSH);
@@ -510,9 +510,9 @@
 	if (max_length && length > max_length)
 	    length = max_length;
 
-	if (_PyBytes_Resize(&RetVal, length) < 0)
+	if (_PyString_Resize(&RetVal, length) < 0)
 	    goto error;
-	self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+	self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 	    + old_length;
 	self->zst.avail_out = length - old_length;
 
@@ -525,7 +525,7 @@
        of specified size. Return the unconsumed tail in an attribute.*/
     if(max_length) {
 	Py_DECREF(self->unconsumed_tail);
-	self->unconsumed_tail = PyBytes_FromStringAndSize((char *)self->zst.next_in,
+	self->unconsumed_tail = PyString_FromStringAndSize((char *)self->zst.next_in,
 							   self->zst.avail_in);
 	if(!self->unconsumed_tail) {
 	    Py_DECREF(RetVal);
@@ -542,7 +542,7 @@
     */
     if (err == Z_STREAM_END) {
 	Py_XDECREF(self->unused_data);  /* Free original empty string */
-	self->unused_data = PyBytes_FromStringAndSize(
+	self->unused_data = PyString_FromStringAndSize(
 	    (char *)self->zst.next_in, self->zst.avail_in);
 	if (self->unused_data == NULL) {
 	    Py_DECREF(RetVal);
@@ -559,7 +559,7 @@
 	goto error;
     }
 
-    _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+    _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 
  error:
     LEAVE_ZLIB
@@ -589,10 +589,10 @@
     /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
        doing any work at all; just return an empty string. */
     if (flushmode == Z_NO_FLUSH) {
-	return PyBytes_FromStringAndSize(NULL, 0);
+	return PyString_FromStringAndSize(NULL, 0);
     }
 
-    if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+    if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 	return NULL;
 
     ENTER_ZLIB
@@ -600,7 +600,7 @@
     start_total_out = self->zst.total_out;
     self->zst.avail_in = 0;
     self->zst.avail_out = length;
-    self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+    self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 
     Py_BEGIN_ALLOW_THREADS
     err = deflate(&(self->zst), flushmode);
@@ -609,9 +609,9 @@
     /* while Z_OK and the output buffer is full, there might be more output,
        so extend the output buffer and try again */
     while (err == Z_OK && self->zst.avail_out == 0) {
-	if (_PyBytes_Resize(&RetVal, length << 1) < 0)
+	if (_PyString_Resize(&RetVal, length << 1) < 0)
 	    goto error;
-	self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+	self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 	    + length;
 	self->zst.avail_out = length;
 	length = length << 1;
@@ -646,7 +646,7 @@
 	goto error;
     }
 
-    _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+    _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 
  error:
     LEAVE_ZLIB
@@ -778,7 +778,7 @@
 	PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
 	return NULL;
     }
-    if (!(retval = PyBytes_FromStringAndSize(NULL, length)))
+    if (!(retval = PyString_FromStringAndSize(NULL, length)))
 	return NULL;
 
 
@@ -786,7 +786,7 @@
 
     start_total_out = self->zst.total_out;
     self->zst.avail_out = length;
-    self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval);
+    self->zst.next_out = (Byte *)PyString_AS_STRING(retval);
 
     Py_BEGIN_ALLOW_THREADS
     err = inflate(&(self->zst), Z_FINISH);
@@ -795,9 +795,9 @@
     /* while Z_OK and the output buffer is full, there might be more output,
        so extend the output buffer and try again */
     while ((err == Z_OK || err == Z_BUF_ERROR) && self->zst.avail_out == 0) {
-	if (_PyBytes_Resize(&retval, length << 1) < 0)
+	if (_PyString_Resize(&retval, length << 1) < 0)
 	    goto error;
-	self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval) + length;
+	self->zst.next_out = (Byte *)PyString_AS_STRING(retval) + length;
 	self->zst.avail_out = length;
 	length = length << 1;
 
@@ -819,7 +819,7 @@
 	    goto error;
 	}
     }
-    _PyBytes_Resize(&retval, self->zst.total_out - start_total_out);
+    _PyString_Resize(&retval, self->zst.total_out - start_total_out);
 
 error:
 
@@ -1027,7 +1027,7 @@
     PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
     PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
 
-    ver = PyBytes_FromString(ZLIB_VERSION);
+    ver = PyString_FromString(ZLIB_VERSION);
     if (ver != NULL)
 	PyModule_AddObject(m, "ZLIB_VERSION", ver);