PYTHON-1153 - Make docs build and test under python 3

Author: behackett

bson/json_util.py

@@ -30,8 +30,8 @@
  >>> from bson.json_util import dumps
  >>> dumps([{'foo': [1, 2]},
  ... {'bar': {'hello': 'world'}},
- ... {'code': Code("function x() { return 1; }")},
- ... {'bin': Binary("\x01\x02\x03\x04")}])
+ ... {'code': Code("function x() { return 1; }", {})},
+ ... {'bin': Binary(b"\x01\x02\x03\x04")}])
  '[{"foo": [1, 2]}, {"bar": {"hello": "world"}}, {"code": {"$code": "function x() { return 1; }", "$scope": {}}}, {"bin": {"$binary": "AQIDBA==", "$type": "00"}}]'
 
 Example usage (deserialization):

doc/conf.py

@@ -66,9 +66,9 @@
 # -- Options for extensions ----------------------------------------------------
 autoclass_content = 'init'
 
-doctest_path = os.path.abspath('..')
+doctest_path = [os.path.abspath('..')]
 
-doctest_test_doctest_blocks = False
+doctest_test_doctest_blocks = ''
 
 doctest_global_setup = """
 from pymongo.mongo_client import MongoClient

doc/examples/aggregation.rst

@@ -56,8 +56,11 @@ eg "$sort":
  ... {"$group": {"_id": "$tags", "count": {"$sum": 1}}},
  ... {"$sort": SON([("count", -1), ("_id", -1)])}
  ... ]
- >>> list(db.things.aggregate(pipeline))
- [{u'count': 3, u'_id': u'cat'}, {u'count': 2, u'_id': u'dog'}, {u'count': 1, u'_id': u'mouse'}]
+ >>> import pprint
+ >>> pprint.pprint(list(db.things.aggregate(pipeline)))
+ [{u'_id': u'cat', u'count': 3},
+ {u'_id': u'dog', u'count': 2},
+ {u'_id': u'mouse', u'count': 1}]
 
 To run an explain plan for this aggregation use the
 :meth:`~pymongo.database.Database.command` method::
@@ -118,7 +121,7 @@ iterate over the result collection:
 
  >>> result = db.things.map_reduce(mapper, reducer, "myresults")
  >>> for doc in result.find():
- ... print doc
+ ... pprint.pprint(doc)
  ...
  {u'_id': u'cat', u'value': 3.0}
  {u'_id': u'dog', u'value': 2.0}
@@ -135,18 +138,23 @@ response to the map/reduce command, rather than just the result collection:
 
 .. doctest::
 
- >>> db.things.map_reduce(mapper, reducer, "myresults", full_response=True)
- {u'counts': {u'input': 4, u'reduce': 2, u'emit': 6, u'output': 3}, u'timeMillis': ..., u'ok': ..., u'result': u'...'}
+ >>> pprint.pprint(
+ ... db.things.map_reduce(mapper, reducer, "myresults", full_response=True))
+ {u'counts': {u'emit': 6, u'input': 4, u'output': 3, u'reduce': 2},
+ u'ok': ...,
+ u'result': u'...',
+ u'timeMillis': ...}
 
 All of the optional map/reduce parameters are also supported, simply pass them
 as keyword arguments. In this example we use the `query` parameter to limit the
 documents that will be mapped over:
 
 .. doctest::
 
- >>> result = db.things.map_reduce(mapper, reducer, "myresults", query={"x": {"$lt": 2}})
- >>> for doc in result.find():
- ... print doc
+ >>> results = db.things.map_reduce(
+ ... mapper, reducer, "myresults", query={"x": {"$lt": 2}})
+ >>> for doc in results.find():
+ ... pprint.pprint(doc)
  ...
  {u'_id': u'cat', u'value': 1.0}
  {u'_id': u'dog', u'value': 1.0}
@@ -157,8 +165,16 @@ specify a different database to store the result collection:
 .. doctest::
 
  >>> from bson.son import SON
- >>> db.things.map_reduce(mapper, reducer, out=SON([("replace", "results"), ("db", "outdb")]), full_response=True)
- {u'counts': {u'input': 4, u'reduce': 2, u'emit': 6, u'output': 3}, u'timeMillis': ..., u'ok': ..., u'result': {u'db': ..., u'collection': ...}}
+ >>> pprint.pprint(
+ ... db.things.map_reduce(
+ ... mapper,
+ ... reducer,
+ ... out=SON([("replace", "results"), ("db", "outdb")]),
+ ... full_response=True))
+ {u'counts': {u'emit': 6, u'input': 4, u'output': 3, u'reduce': 2},
+ u'ok': ...,
+ u'result': {u'collection': ..., u'db': ...},
+ u'timeMillis': ...}
 
 .. seealso:: The full list of options for MongoDB's `map reduce engine <http://www.mongodb.org/display/DOCS/MapReduce>`_
 
@@ -186,7 +202,7 @@ Here we are doing a simple group and count of the occurrences of ``x`` values:
  ...
  >>> results = db.things.group(key={"x":1}, condition={}, initial={"count": 0}, reduce=reducer)
  >>> for doc in results:
- ... print doc
+ ... pprint.pprint(doc)
  {u'count': 1.0, u'x': 1.0}
  {u'count': 2.0, u'x': 2.0}
  {u'count': 1.0, u'x': 3.0}

doc/examples/bulk.rst

@@ -27,7 +27,7 @@ bulk insert operations.
 
  >>> import pymongo
  >>> db = pymongo.MongoClient().bulk_example
- >>> db.test.insert_many([{'i': i} for i in xrange(10000)]).inserted_ids
+ >>> db.test.insert_many([{'i': i} for i in range(10000)]).inserted_ids
  [...]
  >>> db.test.count()
  10000
@@ -51,6 +51,7 @@ order provided for serial execution. The return value is a document
 describing the type and count of operations performed.
 
 .. doctest::
+ :options: +NORMALIZE_WHITESPACE
 
  >>> from pprint import pprint
  >>>
@@ -88,6 +89,7 @@ occurred and details about the failure - including the operation that caused
 the failure.
 
 .. doctest::
+ :options: +NORMALIZE_WHITESPACE
 
  >>> from pymongo.errors import BulkWriteError
  >>> bulk = db.test.initialize_ordered_bulk_op()
@@ -99,7 +101,7 @@ the failure.
  >>> try:
  ... bulk.execute()
  ... except BulkWriteError as bwe:
- ... pprint(bwe.details) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+ ... pprint(bwe.details)
  ... 
  {'nInserted': 0,
  'nMatched': 1,
@@ -127,6 +129,7 @@ constraint on _id. Since we are doing unordered execution the second
 and fourth operations succeed.
 
 .. doctest::
+ :options: +NORMALIZE_WHITESPACE
 
  >>> bulk = db.test.initialize_unordered_bulk_op()
  >>> bulk.insert({'_id': 1})
@@ -136,7 +139,7 @@ and fourth operations succeed.
  >>> try:
  ... bulk.execute()
  ... except BulkWriteError as bwe:
- ... pprint(bwe.details) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+ ... pprint(bwe.details)
  ... 
  {'nInserted': 0,
  'nMatched': 1,
@@ -165,6 +168,7 @@ errors (e.g. wtimeout) will be reported after all operations are attempted,
 regardless of execution order.
 
 .. doctest::
+ :options: +NORMALIZE_WHITESPACE
 
  >>> bulk = db.test.initialize_ordered_bulk_op()
  >>> bulk.insert({'a': 0})

doc/examples/custom_type.rst

@@ -88,10 +88,12 @@ use them with PyMongo:
 
 .. doctest::
 
+ >>> import pprint
  >>> db.test.insert({"custom": encode_custom(Custom(5))})
  ObjectId('...')
- >>> db.test.find_one()
- {u'_id': ObjectId('...'), u'custom': {u'x': 5, u'_type': u'custom'}}
+ >>> pprint.pprint(db.test.find_one())
+ {u'_id': ObjectId('...'),
+ u'custom': {u'_type': u'custom', u'x': 5}}
  >>> decode_custom(db.test.find_one()["custom"])
  <Custom object at ...>
  >>> decode_custom(db.test.find_one()["custom"]).x()
@@ -142,8 +144,9 @@ After doing so we can save and restore :class:`Custom` instances seamlessly:
  {...}
  >>> db.test.insert({"custom": Custom(5)})
  ObjectId('...')
- >>> db.test.find_one()
- {u'_id': ObjectId('...'), u'custom': <Custom object at ...>}
+ >>> pprint.pprint(db.test.find_one())
+ {u'_id': ObjectId('...'),
+ u'custom': <Custom object at ...>}
  >>> db.test.find_one()["custom"].x()
  5
 
@@ -159,8 +162,9 @@ This allows us to see what was actually saved to the database:
 
 .. doctest::
 
- >>> db.test.find_one()
- {u'_id': ObjectId('...'), u'custom': {u'x': 5, u'_type': u'custom'}}
+ >>> pprint.pprint(db.test.find_one())
+ {u'_id': ObjectId('...'),
+ u'custom': {u'_type': u'custom', u'x': 5}}
 
 which is the same format that we encode to with our
 :meth:`encode_custom` method!
@@ -183,7 +187,7 @@ from :class:`~bson.binary.Binary` instances:
 
  >>> from bson.binary import Binary
  >>> def to_binary(custom):
- ... return Binary(str(custom.x()), 128)
+ ... return Binary(str(custom.x()).encode(), 128)
  ...
  >>> def from_binary(binary):
  ... return Custom(int(binary))
@@ -229,8 +233,9 @@ seamlessly:
 
  >>> db.test.insert({"custom": Custom(5)})
  ObjectId('...')
- >>> db.test.find_one()
- {u'_id': ObjectId('...'), u'custom': <Custom object at ...>}
+ >>> pprint.pprint(db.test.find_one())
+ {u'_id': ObjectId('...'),
+ u'custom': <Custom object at ...>}
  >>> db.test.find_one()["custom"].x()
  5
 
@@ -242,5 +247,5 @@ clearing out the manipulators and repeating our
 .. doctest::
 
  >>> db = client.custom_type_example
- >>> db.test.find_one()
+ >>> pprint.pprint(db.test.find_one())
  {u'_id': ObjectId('...'), u'custom': Binary('5', 128)}

doc/examples/geo.rst

@@ -47,12 +47,13 @@ Using the geospatial index we can find documents near another point:
 
 .. doctest::
 
+ >>> import pprint
  >>> for doc in db.places.find({"loc": {"$near": [3, 6]}}).limit(3):
- ... repr(doc) # doctest: +ELLIPSIS
+ ... pprint.pprint(doc)
  ...
- "{u'loc': [2, 5], u'_id': ObjectId('...')}"
- "{u'loc': [4, 4], u'_id': ObjectId('...')}"
- "{u'loc': [1, 2], u'_id': ObjectId('...')}"
+ {u'_id': ObjectId('...'), u'loc': [2, 5]}
+ {u'_id': ObjectId('...'), u'loc': [4, 4]}
+ {u'_id': ObjectId('...'), u'loc': [1, 2]}
 
 The $maxDistance operator requires the use of :class:`~bson.son.SON`:
 
@@ -61,11 +62,11 @@ The $maxDistance operator requires the use of :class:`~bson.son.SON`:
  >>> from bson.son import SON
  >>> query = {"loc": SON([("$near", [3, 6]), ("$maxDistance", 100)])}
  >>> for doc in db.places.find(query).limit(3):
- ... repr(doc) # doctest: +ELLIPSIS
+ ... pprint.pprint(doc)
  ...
- "{u'loc': [2, 5], u'_id': ObjectId('...')}"
- "{u'loc': [4, 4], u'_id': ObjectId('...')}"
- "{u'loc': [1, 2], u'_id': ObjectId('...')}"
+ {u'_id': ObjectId('...'), u'loc': [2, 5]}
+ {u'_id': ObjectId('...'), u'loc': [4, 4]}
+ {u'_id': ObjectId('...'), u'loc': [1, 2]}
 
 It's also possible to query for all items within a given rectangle
 (specified by lower-left and upper-right coordinates):
@@ -74,21 +75,21 @@ It's also possible to query for all items within a given rectangle
 
  >>> query = {"loc": {"$within": {"$box": [[2, 2], [5, 6]]}}}
  >>> for doc in db.places.find(query).sort('_id'):
- ... repr(doc)
- "{u'loc': [2, 5], u'_id': ObjectId('...')}"
- "{u'loc': [4, 4], u'_id': ObjectId('...')}"
+ ... pprint.pprint(doc)
+ {u'_id': ObjectId('...'), u'loc': [2, 5]}
+ {u'_id': ObjectId('...'), u'loc': [4, 4]}
 
 Or circle (specified by center point and radius):
 
 .. doctest::
 
  >>> query = {"loc": {"$within": {"$center": [[0, 0], 6]}}}
  >>> for doc in db.places.find(query).sort('_id'):
- ... repr(doc) # doctest: +ELLIPSIS
+ ... pprint.pprint(doc)
  ...
- "{u'loc': [2, 5], u'_id': ObjectId('...')}"
- "{u'loc': [1, 2], u'_id': ObjectId('...')}"
- "{u'loc': [4, 4], u'_id': ObjectId('...')}"
+ {u'_id': ObjectId('...'), u'loc': [2, 5]}
+ {u'_id': ObjectId('...'), u'loc': [1, 2]}
+ {u'_id': ObjectId('...'), u'loc': [4, 4]}
 
 geoNear queries are also supported using :class:`~bson.son.SON`::
 

doc/examples/gridfs.rst

@@ -42,7 +42,7 @@ interface (the :meth:`~gridfs.GridFS.put` and
 
 .. doctest::
 
- >>> a = fs.put("hello world")
+ >>> a = fs.put(b"hello world")
 
 :meth:`~gridfs.GridFS.put` creates a new file in GridFS, and returns
 the value of the file document's ``"_id"`` key. Given that ``"_id"``

doc/faq.rst

@@ -214,30 +214,27 @@ PyMongo represents BSON documents as Python dicts by default, and the order
 of keys in dicts is not defined. That is, a dict declared with the "a" key
 first is the same, to Python, as one with "b" first:
 
-.. doctest:: key-order
-
- >>> print {'a': 1.0, 'b': 1.0}
+ >>> print({'a': 1.0, 'b': 1.0})
  {'a': 1.0, 'b': 1.0}
- >>> print {'b': 1.0, 'a': 1.0}
+ >>> print({'b': 1.0, 'a': 1.0})
  {'a': 1.0, 'b': 1.0}
 
 Therefore, Python dicts are not guaranteed to show keys in the order they are
 stored in BSON. Here, "a" is shown before "b":
 
-.. doctest:: key-order
-
- >>> print collection.find_one()
+ >>> print(collection.find_one())
  {u'_id': 1.0, u'subdocument': {u'a': 1.0, u'b': 1.0}}
 
 To preserve order when reading BSON, use the :class:`~bson.son.SON` class,
 which is a dict that remembers its key order. First, get a handle to the
 collection, configured to use :class:`~bson.son.SON` instead of dict:
 
 .. doctest:: key-order
+ :options: +NORMALIZE_WHITESPACE
 
  >>> from bson import CodecOptions, SON
  >>> opts = CodecOptions(document_class=SON)
- >>> opts # doctest: +NORMALIZE_WHITESPACE
+ >>> opts
  CodecOptions(document_class=<class 'bson.son.SON'>,
  tz_aware=False,
  uuid_representation=PYTHON_LEGACY,
@@ -250,7 +247,7 @@ Now, documents and subdocuments in query results are represented with
 
 .. doctest:: key-order
 
- >>> print collection_son.find_one()
+ >>> print(collection_son.find_one())
  SON([(u'_id', 1.0), (u'subdocument', SON([(u'b', 1.0), (u'a', 1.0)]))])
 
 The subdocument's actual storage layout is now visible: "b" is before "a".
@@ -260,24 +257,18 @@ serialized **to** BSON. But MongoDB considers subdocuments equal only if their
 keys have the same order. So if you use a dict to query on a subdocument it may
 not match:
 
-.. doctest:: key-order
-
  >>> collection.find_one({'subdocument': {'a': 1.0, 'b': 1.0}}) is None
  True
 
 Swapping the key order in your query makes no difference:
 
-.. doctest:: key-order
-
  >>> collection.find_one({'subdocument': {'b': 1.0, 'a': 1.0}}) is None
  True
 
 ... because, as we saw above, Python considers the two dicts the same.
 
 There are two solutions. First, you can match the subdocument field-by-field:
 
-.. doctest:: key-order
-
  >>> collection.find_one({'subdocument.a': 1.0,
  ... 'subdocument.b': 1.0})
  {u'_id': 1.0, u'subdocument': {u'a': 1.0, u'b': 1.0}}
@@ -289,8 +280,6 @@ keys besides "a" and "b", whereas the previous query required an exact match.
 
 The second solution is to use a :class:`~bson.son.SON` to specify the key order:
 
-.. doctest:: key-order
-
  >>> query = {'subdocument': SON([('b', 1.0), ('a', 1.0)])}
  >>> collection.find_one(query)
  {u'_id': 1.0, u'subdocument': {u'a': 1.0, u'b': 1.0}}