python - JSON-Serialisierung von Google App Engine-Modellen



6 Answers

Dies ist die einfachste Lösung, die ich gefunden habe. Es erfordert nur 3 Zeilen Codes.

Fügen Sie Ihrem Modell einfach eine Methode hinzu, um ein Wörterbuch zurückzugeben:

class DictModel(db.Model):
    def to_dict(self):
       return dict([(p, unicode(getattr(self, p))) for p in self.properties()])

SimpleJSON funktioniert jetzt richtig:

class Photo(DictModel):
   filename = db.StringProperty()
   title = db.StringProperty()
   description = db.StringProperty(multiline=True)
   date_taken = db.DateTimeProperty()
   date_uploaded = db.DateTimeProperty(auto_now_add=True)
   album = db.ReferenceProperty(Album, collection_name='photo')

from django.utils import simplejson
from google.appengine.ext import webapp

class PhotoHandler(webapp.RequestHandler):
   def get(self):
      photos = Photo.all()
      self.response.out.write(simplejson.dumps([p.to_dict() for p in photos]))
python json google-app-engine

Ich habe lange gesucht, ohne Erfolg. Mein Projekt verwendet Django nicht, gibt es eine einfache Möglichkeit, App Engine-Modelle (google.appengine.ext.db.Model) in JSON zu serialisieren oder muss ich meinen eigenen Serializer schreiben?

Modell:

class Photo(db.Model):
    filename = db.StringProperty()
    title = db.StringProperty()
    description = db.StringProperty(multiline=True)
    date_taken = db.DateTimeProperty()
    date_uploaded = db.DateTimeProperty(auto_now_add=True)
    album = db.ReferenceProperty(Album, collection_name='photo')



Um Modelle zu serialisieren, fügen Sie einen benutzerdefinierten Json-Encoder wie im folgenden Python hinzu:

import datetime
from google.appengine.api import users
from google.appengine.ext import db
from django.utils import simplejson

class jsonEncoder(simplejson.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return obj.isoformat()

        elif isinstance(obj, db.Model):
            return dict((p, getattr(obj, p)) 
                        for p in obj.properties())

        elif isinstance(obj, users.User):
            return obj.email()

        else:
            return simplejson.JSONEncoder.default(self, obj)


# use the encoder as: 
simplejson.dumps(model, cls=jsonEncoder)

Dies wird kodieren:

  • ein Datum wie Isoformat String ( nach diesem Vorschlag ),
  • ein Modell als ein Diktat seiner Eigenschaften,
  • ein Benutzer als seine E-Mail.

Um das Datum zu dekodieren, können Sie dieses Javascript verwenden:

function decodeJsonDate(s){
  return new Date( s.slice(0,19).replace('T',' ') + ' GMT' );
} // Note that this function truncates milliseconds.

Hinweis: Danke an den Benutzer pydave der diesen Code bearbeitet hat, um ihn lesbarer zu machen. Ich hatte ursprünglich die if / else-Ausdrücke von python verwendet, um jsonEncoder in weniger Zeilen wie folgt auszudrücken: (Ich habe einige Kommentare hinzugefügt und google.appengine.ext.db.to_dict , um es klarer als das Original zu machen.)

class jsonEncoder(simplejson.JSONEncoder):
  def default(self, obj):
    isa=lambda x: isinstance(obj, x) # isa(<type>)==True if obj is of type <type>
    return obj.isoformat() if isa(datetime.datetime) else \
           db.to_dict(obj) if isa(db.Model) else \
           obj.email()     if isa(users.User) else \
           simplejson.JSONEncoder.default(self, obj)



Für einfache Fälle mag ich den here am Ende des Artikels vertretenen Ansatz:

  # after obtaining a list of entities in some way, e.g.:
  user = users.get_current_user().email().lower();
  col = models.Entity.gql('WHERE user=:1',user).fetch(300, 0)

  # ...you can make a json serialization of name/key pairs as follows:
  json = simplejson.dumps(col, default=lambda o: {o.name :str(o.key())})

Der Artikel enthält am anderen Ende des Spektrums eine komplexe Serializer-Klasse, die Djangos bereichert (und erfordert _meta - nicht sicher, warum Sie Fehler über _meta fehlen, vielleicht der here beschriebene Fehler) mit der Fähigkeit zu serialisieren berechnete Eigenschaften / Methoden. Meistens liegt die Serialisierung irgendwo dazwischen, und für diese ist vielleicht ein introvertierter Ansatz wie @David Wilson vorzuziehen.




Wenn Sie app-engine-patch , wird automatisch das _meta Attribut für Sie deklariert, und dann können Sie django.core.serializers wie Sie es normalerweise bei django-Modellen tun würden (wie im Schlittencode).

App-Engine-Patch hat einige andere coole Features wie eine hybride Authentifizierung (django + google accounts), und der Admin-Teil von django funktioniert.




Ich habe die von share geschriebene JSON Encoder-Klasse erweitert, um share zu unterstützen:

  • Abfrage Ergebnisse Eigenschaften (zB car.owner_set)
  • ReferenceProperty - rekursiv in JSON umwandeln
  • verbose_name - Nur Eigenschaften mit einem verbose_name werden in JSON codiert

    class DBModelJSONEncoder(json.JSONEncoder):
        """Encodes a db.Model into JSON"""
    
        def default(self, obj):
            if (isinstance(obj, db.Query)):
                # It's a reference query (holding several model instances)
                return [self.default(item) for item in obj]
    
            elif (isinstance(obj, db.Model)):
                # Only properties with a verbose name will be displayed in the JSON output
                properties = obj.properties()
                filtered_properties = filter(lambda p: properties[p].verbose_name != None, properties)
    
                # Turn each property of the DB model into a JSON-serializeable entity
                json_dict = dict([(
                        p,
                        getattr(obj, p)
                            if (not isinstance(getattr(obj, p), db.Model))
                            else
                        self.default(getattr(obj, p)) # A referenced model property
                    ) for p in filtered_properties])
    
                json_dict['id'] = obj.key().id() # Add the model instance's ID (optional - delete this if you do not use it)
    
                return json_dict
    
            else:
                # Use original JSON encoding
                return json.JSONEncoder.default(self, obj)
    



Es gibt eine Methode "Model.properties ()", die für alle Model-Klassen definiert ist. Es gibt das gesuchte Diktat zurück.

from django.utils import simplejson
class Photo(db.Model):
  # ...

my_photo = Photo(...)
simplejson.dumps(my_photo.properties())

Siehe Modelleigenschaften in den Dokumenten.




Related