#9087: update json docstrings -- unicode and long do not exist anymore.

Lib/json/__init__.py

@@ -125,14 +125,12 @@ def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
     ``.write()``-supporting file-like object).
 
     If ``skipkeys`` is true then ``dict`` keys that are not basic types
-    (``str``, ``unicode``, ``int``, ``float``, ``bool``, ``None``) will be
+    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
-    skipped instead of raising a ``TypeError``.
+    instead of raising a ``TypeError``.
 
-    If ``ensure_ascii`` is false, then the some chunks written to ``fp``
+    If ``ensure_ascii`` is false, then the strings written to ``fp`` can
-    may be ``unicode`` instances, subject to normal Python ``str`` to
+    contain non-ASCII characters if they appear in strings contained in
-    ``unicode`` coercion rules. Unless ``fp.write()`` explicitly
+    ``obj``. Otherwise, all such characters are escaped in JSON strings.
-    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
-    to cause an error.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will
@@ -185,12 +183,12 @@ def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
     """Serialize ``obj`` to a JSON formatted ``str``.
 
     If ``skipkeys`` is false then ``dict`` keys that are not basic types
-    (``str``, ``unicode``, ``int``, ``float``, ``bool``, ``None``) will be
+    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
-    skipped instead of raising a ``TypeError``.
+    instead of raising a ``TypeError``.
 
-    If ``ensure_ascii`` is false, then the return value will be a
+    If ``ensure_ascii`` is false, then the return value can contain non-ASCII
-    ``unicode`` instance subject to normal Python ``str`` to ``unicode``
+    characters if they appear in strings contained in ``obj``. Otherwise, all
-    coercion rules instead of being escaped to an ASCII ``str``.
+    such characters are escaped in JSON strings.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will

Lib/json/decoder.py

@@ -263,9 +263,9 @@ class JSONDecoder(object):
     +---------------+-------------------+
     | array         | list              |
     +---------------+-------------------+
-    | string        | unicode           |
+    | string        | str               |
     +---------------+-------------------+
-    | number (int)  | int, long         |
+    | number (int)  | int               |
     +---------------+-------------------+
     | number (real) | float             |
     +---------------+-------------------+
@@ -318,8 +318,8 @@ class JSONDecoder(object):
 
 
     def decode(self, s, _w=WHITESPACE.match):
-        """Return the Python representation of ``s`` (a ``str`` or ``unicode``
+        """Return the Python representation of ``s`` (a ``str`` instance
-        instance containing a JSON document)
+        containing a JSON document).
 
         """
         obj, end = self.raw_decode(s, idx=_w(s, 0).end())
@@ -329,8 +329,8 @@ class JSONDecoder(object):
         return obj
 
     def raw_decode(self, s, idx=0):
-        """Decode a JSON document from ``s`` (a ``str`` or ``unicode``
+        """Decode a JSON document from ``s`` (a ``str`` beginning with
-        beginning with a JSON document) and return a 2-tuple of the Python
+        a JSON document) and return a 2-tuple of the Python
         representation and the index in ``s`` where the document ended.
 
         This can be used to decode a JSON document from a string that may

Lib/json/encoder.py

@@ -77,9 +77,9 @@ class JSONEncoder(object):
     +-------------------+---------------+
     | list, tuple       | array         |
     +-------------------+---------------+
-    | str, unicode      | string        |
+    | str               | string        |
     +-------------------+---------------+
-    | int, long, float  | number        |
+    | int, float        | number        |
     +-------------------+---------------+
     | True              | true          |
     +-------------------+---------------+
@@ -102,12 +102,12 @@ class JSONEncoder(object):
         """Constructor for JSONEncoder, with sensible defaults.
 
         If skipkeys is false, then it is a TypeError to attempt
-        encoding of keys that are not str, int, long, float or None.  If
+        encoding of keys that are not str, int, float or None.  If
         skipkeys is True, such items are simply skipped.
 
         If ensure_ascii is true, the output is guaranteed to be str
-        objects with all incoming unicode characters escaped.  If
+        objects with all incoming non-ASCII characters escaped.  If
-        ensure_ascii is false, the output will be unicode object.
+        ensure_ascii is false, the output can contain non-ASCII characters.
 
         If check_circular is true, then lists, dicts, and custom encoded
         objects will be checked for circular references during encoding to

Modules/_json.c

@@ -484,7 +484,7 @@ bail:
 }
 
 PyDoc_STRVAR(pydoc_scanstring,
-    "scanstring(basestring, end, strict=True) -> (bytes, end)\n"
+    "scanstring(string, end, strict=True) -> (string, end)\n"
     "\n"
     "Scan the string s for a JSON string. End is the index of the\n"
     "character in s after the quote that started the JSON string.\n"
@@ -512,7 +512,7 @@ py_scanstring(PyObject* self UNUSED, PyObject *args)
     }
     else {
         PyErr_Format(PyExc_TypeError,
-                     "first argument must be a string or bytes, not %.80s",
+                     "first argument must be a string, not %.80s",
                      Py_TYPE(pystr)->tp_name);
         return NULL;
     }
@@ -520,7 +520,7 @@ py_scanstring(PyObject* self UNUSED, PyObject *args)
 }
 
 PyDoc_STRVAR(pydoc_encode_basestring_ascii,
-    "encode_basestring_ascii(basestring) -> bytes\n"
+    "encode_basestring_ascii(string) -> string\n"
     "\n"
     "Return an ASCII-only JSON representation of a Python string"
 );