TypeError: ObjectId ('') tidak dapat bersambung JSON

Tanggapan saya kembali dari MongoDB setelah menanyakan fungsi agregat pada dokumen menggunakan Python, Ia mengembalikan tanggapan yang valid dan saya dapat mencetaknya tetapi tidak dapat mengembalikannya.

Kesalahan:

TypeError: ObjectId('51948e86c25f4b1d1c0d303c') is not JSON serializable

Mencetak:

{'result': [{'_id': ObjectId('51948e86c25f4b1d1c0d303c'), 'api_calls_with_key': 4, 'api_calls_per_day': 0.375, 'api_calls_total': 6, 'api_calls_without_key': 2}], 'ok': 1.0}

Tetapi ketika saya mencoba untuk kembali:

TypeError: ObjectId('51948e86c25f4b1d1c0d303c') is not JSON serializable

Ini adalah panggilan RESTfull:

@appv1.route('/v1/analytics')
def get_api_analytics():
    # get handle to collections in MongoDB
    statistics = sldb.statistics

    objectid = ObjectId("51948e86c25f4b1d1c0d303c")

    analytics = statistics.aggregate([
    {'$match': {'owner': objectid}},
    {'$project': {'owner': "$owner",
    'api_calls_with_key': {'$cond': [{'$eq': ["$apikey", None]}, 0, 1]},
    'api_calls_without_key': {'$cond': [{'$ne': ["$apikey", None]}, 0, 1]}
    }},
    {'$group': {'_id': "$owner",
    'api_calls_with_key': {'$sum': "$api_calls_with_key"},
    'api_calls_without_key': {'$sum': "$api_calls_without_key"}
    }},
    {'$project': {'api_calls_with_key': "$api_calls_with_key",
    'api_calls_without_key': "$api_calls_without_key",
    'api_calls_total': {'$add': ["$api_calls_with_key", "$api_calls_without_key"]},
    'api_calls_per_day': {'$divide': [{'$add': ["$api_calls_with_key", "$api_calls_without_key"]}, {'$dayOfMonth': datetime.now()}]},
    }}
    ])


    print(analytics)

    return analytics

db terhubung dengan baik dan koleksi ada di sana juga dan saya mendapatkan kembali hasil yang diharapkan yang valid tetapi ketika saya mencoba mengembalikannya memberi saya kesalahan Json. Ada ide bagaimana mengubah respon kembali menjadi JSON. Terima kasih

Anda harus mendefinisikan Anda memiliki JSONEncoderdan menggunakannya:

import json
from bson import ObjectId

class JSONEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, ObjectId):
            return str(o)
        return json.JSONEncoder.default(self, o)

JSONEncoder().encode(analytics)

Itu juga memungkinkan untuk menggunakannya dengan cara berikut.

json.encode(analytics, cls=JSONEncoder)

Pymongo menyediakan json_util - Anda dapat menggunakannya sebagai gantinya untuk menangani jenis BSON

>>> from bson import Binary, Code
>>> from bson.json_util import dumps
>>> dumps([{'foo': [1, 2]},
...        {'bar': {'hello': 'world'}},
...        {'code': Code("function x() { return 1; }")},
...        {'bin': Binary("")}])
'[{"foo": [1, 2]}, {"bar": {"hello": "world"}}, {"code": {"$code": "function x() { return 1; }", "$scope": {}}}, {"bin": {"$binary": "AQIDBA==", "$type": "00"}}]'

Contoh sebenarnya dari json_util .

Tidak seperti jsonify Flask, "dumps" akan mengembalikan string, jadi tidak bisa digunakan sebagai pengganti 1: 1 dari jsonify Flask.

Tetapi pertanyaan ini menunjukkan bahwa kita dapat membuat serial menggunakan json_util.dumps (), mengkonversi kembali ke dict menggunakan json.loads () dan terakhir memanggil jsonify Flask di atasnya.

Contoh (berasal dari jawaban pertanyaan sebelumnya):

from bson import json_util, ObjectId
import json

#Lets create some dummy document to prove it will work
page = {'foo': ObjectId(), 'bar': [ObjectId(), ObjectId()]}

#Dump loaded BSON to valid JSON string and reload it as dict
page_sanitized = json.loads(json_util.dumps(page))
return page_sanitized

Solusi ini akan mengonversi ObjectId dan lainnya (yaitu Biner, Kode, dll) menjadi string yang setara seperti "$ oid."

Keluaran JSON akan terlihat seperti ini:

{
  "_id": {
    "$oid": "abc123"
  }
}

from bson import json_util
import json

@app.route('/')
def index():
    for _ in "collection_name".find():
        return json.dumps(i, indent=4, default=json_util.default)

Ini adalah contoh contoh untuk mengubah BSON menjadi objek JSON. Anda bisa mencobanya.

Sebagian besar pengguna yang menerima kesalahan "tidak dapat disambung JSON" hanya perlu menentukan default=strsaat menggunakan json.dumps. Sebagai contoh:

json.dumps(my_obj, default=str)

Ini akan memaksa konversi ke str, mencegah kesalahan. Tentu saja kemudian lihat keluaran yang dihasilkan untuk memastikan bahwa itu yang Anda butuhkan.

Sebagai pengganti cepat, Anda dapat beralih {'owner': objectid}ke {'owner': str(objectid)}.

Tetapi menentukan milik Anda sendiri JSONEncoderadalah solusi yang lebih baik, itu tergantung pada kebutuhan Anda.

Posting di sini karena menurut saya mungkin berguna untuk orang yang menggunakan Flaskwith pymongo. Ini adalah pengaturan "praktik terbaik" saya saat ini untuk mengizinkan flask mengatur tipe data pymongo bson.

mongoflask.py

from datetime import datetime, date

import isodate as iso
from bson import ObjectId
from flask.json import JSONEncoder
from werkzeug.routing import BaseConverter


class MongoJSONEncoder(JSONEncoder):
    def default(self, o):
        if isinstance(o, (datetime, date)):
            return iso.datetime_isoformat(o)
        if isinstance(o, ObjectId):
            return str(o)
        else:
            return super().default(o)


class ObjectIdConverter(BaseConverter):
    def to_python(self, value):
        return ObjectId(value)

    def to_url(self, value):
        return str(value)

app.py

from .mongoflask import MongoJSONEncoder, ObjectIdConverter

def create_app():
    app = Flask(__name__)
    app.json_encoder = MongoJSONEncoder
    app.url_map.converters['objectid'] = ObjectIdConverter

    # Client sends their string, we interpret it as an ObjectId
    @app.route('/users/<objectid:user_id>')
    def show_user(user_id):
        # setup not shown, pretend this gets us a pymongo db object
        db = get_db()

        # user_id is a bson.ObjectId ready to use with pymongo!
        result = db.users.find_one({'_id': user_id})

        # And jsonify returns normal looking json!
        # {"_id": "5b6b6959828619572d48a9da",
        #  "name": "Will",
        #  "birthday": "1990-03-17T00:00:00Z"}
        return jsonify(result)


    return app

Mengapa ini alih-alih melayani BSON atau mongod extended JSON ?

Menurut saya, melayani mongo khusus JSON membebani aplikasi klien. Sebagian besar aplikasi klien tidak akan peduli menggunakan objek mongo dengan cara yang rumit. Jika saya melayani json diperpanjang, sekarang saya harus menggunakannya di sisi server, dan sisi klien. ObjectIddan Timestamplebih mudah untuk digunakan sebagai string dan ini membuat semua kegilaan mongo marshalling ini dikarantina ke server.

{
  "_id": "5b6b6959828619572d48a9da",
  "created_at": "2018-08-08T22:06:17Z"
}

Saya pikir ini tidak terlalu memberatkan untuk bekerja dengan sebagian besar aplikasi daripada.

{
  "_id": {"$oid": "5b6b6959828619572d48a9da"},
  "created_at": {"$date": 1533837843000}
}

Beginilah cara saya baru-baru ini memperbaiki kesalahan

    @app.route('/')
    def home():
        docs = []
        for doc in db.person.find():
            doc.pop('_id') 
            docs.append(doc)
        return jsonify(docs)

Saya tahu saya terlambat memposting tetapi saya pikir itu akan membantu setidaknya beberapa orang!

Kedua contoh yang disebutkan oleh tim dan defuz (yang dipilih terbanyak) berfungsi dengan baik. Namun, ada perbedaan menit yang terkadang bisa signifikan.

1. Metode berikut menambahkan satu bidang tambahan yang berlebihan dan mungkin tidak ideal di semua kasus

Pymongo menyediakan json_util - Anda dapat menggunakannya sebagai gantinya untuk menangani jenis BSON

Keluaran: {"_id": {"$ oid": "abc123"}}

2. Sedangkan kelas JsonEncoder memberikan keluaran yang sama dalam format string seperti yang kita butuhkan dan kita perlu menggunakan json.loads (keluaran) sebagai tambahan. Tapi itu mengarah ke

Keluaran: {"_id": "abc123"}

Meski cara pertama terlihat sederhana, kedua cara tersebut membutuhkan tenaga yang sangat minim.

dalam kasus saya, saya membutuhkan sesuatu seperti ini:

class JsonEncoder():
    def encode(self, o):
        if '_id' in o:
            o['_id'] = str(o['_id'])
        return o

Jsonify Flask menyediakan peningkatan keamanan seperti yang dijelaskan dalam Keamanan JSON . Jika pembuat enkode khusus digunakan dengan Flask, sebaiknya pertimbangkan poin-poin yang dibahas dalam Keamanan JSON

Saya ingin memberikan solusi tambahan yang meningkatkan jawaban yang diterima. Saya sebelumnya telah memberikan jawaban di utas lain di sini .

from flask import Flask
from flask.json import JSONEncoder

from bson import json_util

from . import resources

# define a custom encoder point to the json_util provided by pymongo (or its dependency bson)
class CustomJSONEncoder(JSONEncoder):
    def default(self, obj): return json_util.default(obj)

application = Flask(__name__)
application.json_encoder = CustomJSONEncoder

if __name__ == "__main__":
    application.run()

Jika Anda tidak memerlukan _id dari catatan, saya akan merekomendasikan untuk tidak menyetelnya saat menanyakan DB yang akan memungkinkan Anda untuk mencetak catatan yang dikembalikan secara langsung, mis.

Untuk menghapus _id saat membuat kueri dan kemudian mencetak data dalam satu lingkaran, Anda menulis sesuatu seperti ini

records = mycollection.find(query, {'_id': 0}) #second argument {'_id':0} unsets the id from the query
for record in records:
    print(record)

SOLUSI untuk: mongoengine + marshmallow

Jika Anda menggunakan mongoenginedan marshamallowkemudian solusi ini mungkin berlaku untuk Anda.

Pada dasarnya, saya mengimpor Stringbidang dari marshmallow, dan saya menimpa default Schema iduntuk Stringdikodekan.

from marshmallow import Schema
from marshmallow.fields import String

class FrontendUserSchema(Schema):

    id = String()

    class Meta:
        fields = ("id", "email")

from bson.objectid import ObjectId
from core.services.db_connection import DbConnectionService

class DbExecutionService:
     def __init__(self):
        self.db = DbConnectionService()

     def list(self, collection, search):
        session = self.db.create_connection(collection)
        return list(map(lambda row: {i: str(row[i]) if isinstance(row[i], ObjectId) else row[i] for i in row}, session.find(search))

Jika Anda tidak ingin _idmenanggapi, Anda dapat memfaktorkan ulang kode Anda seperti ini:

jsonResponse = getResponse(mock_data)
del jsonResponse['_id'] # removes '_id' from the final response
return jsonResponse

Ini akan menghapus TypeError: ObjectId('') is not JSON serializablekesalahan.