Flask restful: comment documenter le corps de réponse avec fields.Dict()?

Question

Dans flask-restplus, je veux modéliser le corps de la réponse qui a une structure de liste imbriquée, donc chaque fois que j'appelle l'API, le corps de la réponse sera renvoyé comme prévu. Dans le corps de la réponse, il a une structure imbriquée, je ne sais pas comment documenter cela. Dois-je utiliser fields.Dict()? est-ce que quelqu'un peut me montrer comment faire cela dans flask-restplus?

corps de la réponse:

{
  "score": 0,
  "category": "low",
  "guidance": "string",
  "is_ready": true,
  "used_features": [
    {
      "name": "hear_rate",
      "value": 1002,
      "range_value": [
        10,
        1000,
        10000,
        20000
      ],
      "range_frequency": [
        80,
        15,
        2,
        1
      ],
      "importance": 1
    },
    {
      "name": "pressure",
      "value": 400,
      "range_value": [
        10,
        1000,
        3000
      ],
      "range_frequency": [
        85,
        10,
        5
      ],
      "importance": 2
    }
  ]
}

ma solution partielle:

voici ma solution partielle

from flask import Flask, jsonify
from flask_restplus import Api, Resource, fields, reqparse, inputs

app = Flask(__name__)
api = Api(app)
ns = api.namespace('ns')

payload = api.model('Payload', {
    'score': fields.Integer,
    'category': fields.String,
    'guidance': fields.String,
    'is_ready': fields.Boolean,
    ## comment ajouter des tableaux de caractéristiques utilisées
})

@ns.route('/')
class AResource(Resource):
    @ns.expect(payload)
    def get(self):
        parser = reqparse.RequestParser()
        parser.add_argument('score', type=str, required=True)
        parser.add_argument('category', type=str, required=True)
        parser.add_argument('guidance', type=str, required=True)
        parser.add_argument('category', type=str, required=True)
        parser.add_argument('is_ready', type= bool, required=True)
        try:  # Lèvera une erreur si la date ne peut pas être analysée.
            args = parser.parse_args()  # type "dict"
            return jsonify(args)
        except:
            return None, 400

if __name__ == '__main__':
    app.run(debug=True)

dans mon code tenté, je n'ai pas pu trouver de solution sur la façon de modéliser le dictionnaire used_features. Y a-t-il un moyen de corriger le défaut de la tentative précédente? quelqu'un peut-il me montrer comment faire en sorte que cela fonctionne où je peux modéliser correctement le corps de la réponse? Dois-je utiliser Dict ou Nested dans mon code? des réflexions supplémentaires? merci

Answer 1

Utilisez @ns.marshal_with(payload).

Le décorateur marshal_with() est ce qui prend réellement votre objet de données et applique le filtrage des champs. Le marshalling peut fonctionner sur des objets simples, des dictionnaires ou des listes d'objets. Lien vers la ressource Marshalling : https://flaskrestplus.readthedocs.io/en/stable/marshalling.html

Et pour modéliser les used_features, utilisez fields.Nested. J'ai montré comment l'utiliser dans le code suivant.

from flask import Flask, jsonify
from flask_restplus import Namespace, Resource, fields, reqparse
from flask_restplus import Api

app = Flask(__name__)
api = Api(app)
ns = api.namespace('ns')

used_features = {}
used_features['name'] = fields.String(attribute='name')
used_features['value'] = fields.Integer(attribute='value')
used_features['range_value'] = fields.List(
    fields.Integer, attribute='range_value')
used_features['range_frequency'] = fields.List(
    fields.Integer, attribute='range_frequency')
used_features['importance'] = fields.Integer(attribute='importance')

used_features_payload = api.model('feature_payload', used_features)

payload = api.model('Payload', {
    'score': fields.Integer,
    'category': fields.String,
    'guidance': fields.String,
    'is_ready': fields.Boolean,
    'used_features': fields.Nested(used_features_payload)
    # comment ajouter les tableaux de caractéristiques utilisées
})

@ns.route('/')
class AResource(Resource):
    @ns.expect(payload)
    @ns.marshal_with(payload)
    def get(self):
        parser = reqparse.RequestParser()
        parser.add_argument('score', type=str, required=True)
        parser.add_argument('category', type=str, required=True)
        parser.add_argument('guidance', type=str, required=True)
        parser.add_argument('category', type=str, required=True)
        parser.add_argument('is_ready', type=bool, required=True)
        try:  # Lève une erreur si la date ne peut pas être analysée.
            args = parser.parse_args()  # type "dict"
            return jsonify(args)
        except:
            return None, 400

if __name__ == '__main__':
    app.run(debug=True, port=1234)