Is it possible to use flask_restful + marshmallow

I’m looking at this example that uses the docstring to specify the swagger: https://github.com/rochacbruno/flasgger/blob/master/examples/restful.py

In this example it seems like I cannot use use @swag_from like in the marshmallow example, instead I must use the docstring to pass the swagger description: https://github.com/rochacbruno/flasgger/blob/master/examples/marshmallow_apispec.py

However, I would like to define my models using a Marshmallow schema, and then simply refer to those in the $ref. Is that possible?

I mean currently, since I never tell flasgger anywhere about my schemas, it does not know that it should output them to the definitions in the final swagger JSON. Can I make it do this somehow?

There’s a lot of overlapping functionality with all these projects flask, flask_restful and marshmallow, so maybe there is some easier way.

[ghost]

I made a little workaround, “not beautiful but rare”. At first I tried to register my Schemas via the swagger.definition decorator. As this decorator accepts only classes with the yaml docstring annotation I shortly converted the Marshmallow-Schema to these (Named “Magic” here as it does the very uncommon stuff; Also cut some sqlalchemy stuff from my application, so it has no claim to be complete):

from flask import Flask, request, Response
from flask_marshmallow import Marshmallow
from marshmallow import fields
import yaml
from flasgger.marshmallow_apispec import schema2jsonschema
from flasgger import Swagger, Schema
from flask_restful import Api, Resource

app = Flask(__name__)
ma = Marshmallow(app)
api = Api(app)
swagger = Swagger(app)


def definition(name):
    def magic(schema_class):
        # Build the schema definition as a json
        spec = schema2jsonschema(schema_class)
        # convert the json objects to a yaml
        yaml_spec = yaml.dump(spec)
        # build the docstring. something like: 
        # """Plugin
        # ---
        # properties:
        # description:
        #     type: string
        # id:
        #     type: integer
        # name:
        #     type: string
        # type: object
        # """
        as_docstring = f"{name}\n---\n{yaml_spec}"

        # Define a class and place the docstring
        class Magic(object):
            pass

        Magic.__doc__ = as_docstring
        # invoke the decorator with our class
        swagger.definition(name)(Magic)
        return schema_class

    return magic


@definition("Plugin")
class PluginSchema(Schema):
    class Meta:
        model = Plugin

    id = fields.Integer()
    name = fields.String()
    description = fields.String()


plugin_schema = PluginSchema()
plugins_schema = PluginSchema(many=True)


class PluginListResource(Resource):
    def get(self):
        """
        Get a list of plugins.
        ---
        responses:
            200:
                description: A list of plugins
                schema:
                    type: "array"
                    items:
                        $ref: "#/definitions/Plugin"
        """
        plugins = Plugin.query
        return plugins_schema.dump(plugins)

    def post(self):
        """
        Create a new plugin
        ---
        parameters:
            - in: body
              name: body
              schema:
                  $ref: '#/definitions/Plugin'
        responses:
            200:
                description: The plugin that has been generated.
                schema:
                    $ref: "#/definitions/Plugin"
        """
        new_plugin = Plugin(
            name=request.json['name'],
            description=request.json['description'],
        )
        db.session.add(new_plugin)
        db.session.commit()
        return plugin_schema.dump(new_plugin)


api.add_resource(PluginListResource, '/plugins')

I hope this helps anyone who finds this ticket like me 😃 Also, maybe I missed a way where this is implemented correctly inside flasgger, this was only an internal prototype anyway. It still would be nice to have a common way for this (maybe by just adjusting the swagger.definition decorator, like

@swagger.definition("Plugin")
class PluginSchema(Schema):
    class Meta:
        model = Plugin

    id = fields.Integer()
    name = fields.String()
    description = fields.String()

).

[netrounds-joakim]

Ah yes that is one use case.

But from articulating my question and now looking at the Marshmallow example again I now saw this that I had missed before: https://github.com/rochacbruno/flasgger/blob/master/examples/marshmallow_apispec.py#L45-L47

definitions = {
     'User': User  # if nto informed will be extracted from usage above
}

Which does what I requested above. Except that it’s inside of the SwaggerView class. And it works now like I want 😃