Skip to content

flask_restx_marshmallow ¤

flask-restx-marshmallow.

Api ¤

Bases: Api

Patched API.

__schema__ ¤

__schema__() -> OpenAPI

The Swagger specifications/schema for this API.

Raises:

Type Description
ValueError

Unable to render schema

Returns:

Name Type Description
OpenAPI OpenAPI

swagger
Source code in flask_restx_marshmallow/api.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
@cached_property
def __schema__(self: Self) -> "OpenAPI":
    """The Swagger specifications/schema for this API.

    Raises:
        ValueError: Unable to render schema

    Returns:
        OpenAPI: swagger
    """
    if not self._schema:
        try:
            self._schema = Swagger(self).as_dict()
        except Exception as exc:
            msg = "Unable to render schema"
            logger.exception(msg)
            raise ValueError(msg) from exc
    return self._schema

auth_render_swagger ¤

auth_render_swagger(
    func: Callable[
        [Callable[[Api], str | bytes]], Callable[[Api], T]
    ],
) -> None

Add decorator to render swagger ui.

Source code in flask_restx_marshmallow/api.py 
136
137
138
139
140
141
def auth_render_swagger[T](
    self,
    func: Callable[[Callable[["Api"], str | bytes]], Callable[["Api"], T]],
) -> None:
    """Add decorator to render swagger ui."""
    self._swagger_auth_decorator = func

render_doc ¤

render_doc() -> str

Render doc.

Returns:

Name Type Description
str str

rendered doc
Source code in flask_restx_marshmallow/api.py 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
@override
def render_doc(self: Self) -> str:
    """Render doc.

    Returns:
        str: rendered doc
    """
    if (
        self._swagger_auth_decorator is None
        or current_app.config.get("DEBUG") is True
    ):
        return render_swagger_ui(self)
    return cast(
        "str",
        self._swagger_auth_decorator(render_swagger_ui)(self),
    )

render_json ¤

render_json() -> str | bytes

Render swagger json doc.

Returns:

Name Type Description
str str | bytes

rendered json
Source code in flask_restx_marshmallow/api.py 
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
def render_json(self: Self) -> str | bytes:
    """Render swagger json doc.

    Returns:
        str: rendered json
    """
    if (
        self._swagger_auth_decorator is None
        or current_app.config.get("DEBUG") is True
    ):
        return render_swagger_json(self)
    return cast(
        "str | bytes",
        self._swagger_auth_decorator(render_swagger_json)(self),
    )

Error dataclass ¤

Error(
    code: ResponseCode = ERROR,
    message: str | Mapping[str, list[str]] | None = None,
)

error response.

Source code in flask_restx_marshmallow/type.py 
197
198
199
200
201
202
@override
def __init__(
    self,
    code: ResponseCode = ResponseCode.ERROR,
    message: str | Mapping[str, list[str]] | None = None,
) -> "_Error": ...  # type: ignore[override]

__new__ ¤

__new__(
    code: ResponseCode = ERROR,
    message: str | Mapping[str, list[str]] | None = None,
) -> _Error

Error response.

Source code in flask_restx_marshmallow/type.py 
184
185
186
187
188
189
190
191
192
193
def __new__(
    cls,
    code: ResponseCode = ResponseCode.ERROR,
    message: str | Mapping[str, list[str]] | None = None,
) -> "_Error":
    """Error response."""
    instance = super().__new__(cls)
    instance.code = code
    instance.message = message
    return cast("_Error", filter_none(asdict(instance)))

Location ¤

Bases: StrEnum

Location Enum.

Namespace ¤

Bases: Namespace

Patched Namespace.

parameters ¤

parameters(
    params: type[DataclassInstance | Parameters]
    | Parameters,
    *,
    location: Location
    | Literal[
        "query",
        "header",
        "formData",
        "body",
        "cookie",
        "path",
    ]
    | None = None,
    as_kwargs: bool = False,
    validate: Callable[[dict], bool] | None = None,
    **kwargs: Unpack[SchemaInitKwargs],
) -> Callable[
    [
        Callable[P, TupleResponse[A] | Response | A]
        | type[M]
    ],
    Callable[P, TupleResponse[A] | Response | A]
    | type[M],
]

Endpoint parameters registration decorator.

Parameters:

Name Type Description Default

params ¤

 subclass[DataclassInstance | Parameters] | Parameters

parameters class or instance.

 required

as_kwargs ¤

 bool

whether set parameters as key word arguments arguments or not. Defaults to False.

 False

validate ¤

 dict) -> bool

validation function. Defaults to None.

 None

location ¤

 Location

location of the parameters. Defaults to None.

 None

**kwargs ¤

 ParamsInitKwargs

parameters initialization keyword.

 {}

Raises:

Type Description
TypeError

if params is not subclass of Parameters

Returns:

Type Description
((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])

decorator.
Source code in flask_restx_marshmallow/namespace.py 
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
def parameters[A, T: "DataclassInstance", M: "MethodView", **P](
    self: Self,
    params: "type[DataclassInstance | Parameters] | Parameters",
    *,
    location: Location
    | Literal["query", "header", "formData", "body", "cookie", "path"]
    | None = None,
    as_kwargs: bool = False,
    validate: "Callable[[dict], bool] | None" = None,
    **kwargs: Unpack["SchemaInitKwargs"],
) -> Callable[
    [Callable[P, TupleResponse[A] | Response | A] | type[M]],
    Callable[P, TupleResponse[A] | Response | A] | type[M],
]:
    """Endpoint parameters registration decorator.

    Args:
        params (subclass[DataclassInstance | Parameters] | Parameters): parameters class or instance.
        as_kwargs (bool, optional): whether set parameters as key word arguments
            arguments or not. Defaults to False.
        validate ((dict) -> bool, optional): validation function. Defaults to None.
        location (Location, optional): location of the parameters. Defaults to None.
        **kwargs (ParamsInitKwargs): parameters initialization keyword.

    Raises:
        TypeError: if params is not subclass of Parameters

    Returns:
        (((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])): decorator.


    """  # noqa: E501
    if is_dataclass(params):
        params = class_schema(params, base=Parameters, use_origin_load=as_kwargs)
    if isinstance(params, type) and issubclass(params, Parameters):
        params = params(location=location, **kwargs)
    elif not isinstance(params, Parameters):
        msg = f"params must be subclass of Parameters, got {type(params).__name__}"
        raise TypeError(msg)

    def decorator(
        func_or_class: Callable[P, TupleResponse[A] | Response | A] | type[M],
    ) -> Callable[P, TupleResponse[A] | Response | A] | type[M]:
        """Decorator.

        Args:
            func_or_class (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]): function or class to decorate.

        Raises:
            ValueError: if location is None.

        Returns:
            ((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) : decorated function or class.
        """  # noqa: E501
        locations = params.locations
        if None in locations:
            msg = f"location must be specified, {params} has None location."
            raise ValueError(msg)
        if not isinstance(func_or_class, type):
            # * function case
            return parser.use_args(
                params,
                location="auto",
                as_kwargs=as_kwargs,
                validate=validate,
            )(self.doc(params=params)(func_or_class))
        # * class case
        func_or_class.decorators.append(
            parser.use_args(
                params,
                location="auto",
                as_kwargs=as_kwargs,
                validate=validate,
            )(self.doc(params=params)),
        )
        return func_or_class

    return decorator

responses ¤

responses(
    *,
    success: bool = True,
    code: HTTPStatus | int = OK,
    schema: type[T | Schema] | Schema | None = None,
    message: str | None = None,
    headers: Iterable[str] | None = None,
    **kwargs: Unpack[SchemaInitKwargs],
) -> Callable[
    [
        Callable[P, TupleResponse[A] | Response | A]
        | type[M]
    ],
    Callable[P, TupleResponse[A] | Response | A]
    | type[M],
]

Endpoint response OpenAPI documentation decorator.

Parameters:

Name Type Description Default

success ¤

 bool

whether response is successful or not. Defaults to True.

 True

code ¤

 HTTPStatus | int

response status code. Defaults to HTTPStatus.OK.

 OK

message ¤

 str

response message. Defaults to None.

 None

schema ¤

 subclass[DataclassInstance | Schema] | Schema

schema class or instance.

 None

headers ¤

 Iterable[str]

header fields. Defaults to None.

 None

**kwargs ¤

 SchemaInitKwargs

schema initialization keyword arguments.

 {}

Raises:

Type Description
TypeError

if schema is not subclass of Schema.

Returns:

Type Description
((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])

decorator.
Source code in flask_restx_marshmallow/namespace.py 
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
def responses[A, T: "DataclassInstance", M: "MethodView", **P](  # noqa: C901
    self: Self,
    *,
    success: bool = True,
    code: HTTPStatus | int = HTTPStatus.OK,
    schema: "type[T | Schema] | Schema | None" = None,
    message: str | None = None,
    headers: Iterable[str] | None = None,
    **kwargs: Unpack["SchemaInitKwargs"],
) -> Callable[
    [Callable[P, TupleResponse[A] | Response | A] | type[M]],
    Callable[P, TupleResponse[A] | Response | A] | type[M],
]:
    """Endpoint response OpenAPI documentation decorator.

    Args:
        success (bool, optional): whether response is successful or not. Defaults to True.
        code (HTTPStatus | int, optional): response status code. Defaults to HTTPStatus.OK.
        message (str, optional): response message. Defaults to None.
        schema (subclass[DataclassInstance | Schema] | Schema, optional): schema class or instance.
        headers (Iterable[str], optional): header fields. Defaults to None.
        **kwargs (SchemaInitKwargs): schema initialization keyword arguments.

    Raises:
        TypeError: if schema is not subclass of Schema.

    Returns:
       (((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])): decorator.
    """  # noqa: E501
    if is_dataclass(schema):
        schema = class_schema(schema, base=Schema)
    if isinstance(schema, type) and issubclass(schema, Schema):
        schema = schema(header_fields=headers, **kwargs)
    elif not isinstance(schema, Schema) and schema is not None:
        msg = f"schema must be subclass of Schema, got {type(schema).__name__}"
        raise TypeError(msg)

    def decorator(
        func_or_class: Callable[P, TupleResponse[A] | Response | A] | type[M],
    ) -> Callable[P, TupleResponse[A] | Response | A] | type[M]:
        """Decorator.

        Args:
            func_or_class (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]): function or class to decorate.

        Returns:
            ((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) : decorated function or class.
        """  # noqa: E501
        if schema is None:
            splits = func_or_class.__qualname__.split(".")
            name = f"{''.join(s.capitalize() for s in splits)}Schema"
            schema_ = make_default_schema(
                name,
                success=success,
                code=code,
                message=message,
            )(**kwargs)
            doc = parse_from_object(func_or_class)
            schema_.description = (
                doc.long_description or doc.short_description or schema_.description
            )
        else:
            schema_ = schema
            name = type(schema_).__name__
            doc = parse_from_object(schema_)
            schema_.description = (
                doc.long_description or doc.short_description or schema_.description
            )
        body_schema = schema_.copy_body_fields()
        header_schema = schema_.copy_header_fields()
        if not isinstance(func_or_class, type):
            # * function case

            @wraps(func_or_class)
            def wrapper(
                *args: P.args,
                **kwargs: P.kwargs,
            ) -> TupleResponse[A] | Response | A:
                """Wrapper.

                Args:
                    *args (P.args): arguments
                    **kwargs (P.kwargs): key word arguments

                Returns:
                    TupleResponse | Response | Any: response
                """
                resp = func_or_class(*args, **kwargs)
                extra_headers = {}

                if isinstance(resp, Response):
                    return resp
                if isinstance(resp, tuple):
                    response, status_code, extra_headers = unpack(resp)
                else:
                    response = Success(result=resp)
                    status_code = HTTPStatus.OK
                if HTTPStatus(status_code) is HTTPStatus(code):
                    response = body_schema.dump(response)
                    extra_headers = header_schema.dump(extra_headers)
                return TupleResponse(
                    response=response,
                    status_code=status_code,
                    extra_headers=extra_headers,
                )

            return self.doc(responses={str(HTTPStatus(code)): schema_})(wrapper)
        func_or_class.decorators.append(
            self.doc(responses={str(HTTPStatus(code)): schema_}),
        )
        return func_or_class

    return decorator

security ¤

security(
    security: S | Sequence[S],
) -> Callable[
    [
        Callable[P, TupleResponse[A] | Response | A]
        | type[M]
    ],
    Callable[P, TupleResponse[A] | Response | A]
    | type[M],
]

Endpoint security decorator.

Parameters:

Name Type Description Default

security ¤

 S | Sequence[S]

security name or instance.

 required

Returns:

Type Description
((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])

decorator.
Source code in flask_restx_marshmallow/namespace.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
def security[A, S: str | Mapping[str, list[str] | str], M: "MethodView", **P](
    self: Self,
    security: S | Sequence[S],
) -> Callable[
    [Callable[P, TupleResponse[A] | Response | A] | type[M]],
    Callable[P, TupleResponse[A] | Response | A] | type[M],
]:
    """Endpoint security decorator.

    Args:
        security (S | Sequence[S]): security name or instance.

    Returns:
        (((((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView])): decorator.
    """  # noqa: E501
    security_ = (
        [security_helper(security)]
        if not isinstance(security, Sequence)
        else [security_helper(s) for s in security]
    )

    def decorator(
        func_or_class: Callable[P, TupleResponse[A] | Response | A] | type[M],
    ) -> Callable[P, TupleResponse[A] | Response | A] | type[M]:
        """Decorator.

        Args:
            func_or_class (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]): function or class to decorate.

        Returns:
            ((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) -> (((...) -> (TupleResponse | Response | Any)) | subclass[MethodView]) : decorated function or class.
        """  # noqa: E501
        if not isinstance(func_or_class, type):
            # * function case
            return self.doc(security=security_)(func_or_class)
        # * class case
        func_or_class.decorators.append(self.doc(security=security_))
        return func_or_class

    return decorator

Parameters ¤

Parameters(
    *,
    location: Location
    | Literal[
        "query",
        "header",
        "formData",
        "body",
        "cookie",
        "path",
    ]
    | None = None,
    **kwargs: Unpack[SchemaInitKwargs],
)

Bases: Schema

Base Parameters.

Parameters:

Name Type Description Default

location ¤

 Location

location of the parameters. Defaults to None.

 None

kwargs ¤

 dict

other key word arguments.

 {}

Base Parameters.

Parameters:

Name Type Description Default

location ¤

 Location

location of the parameters. Defaults to None.

 None

kwargs ¤

 dict

other key word arguments.

 {}
Source code in flask_restx_marshmallow/parameter.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def __init__(
    self: Self,
    *,
    location: Location
    | Literal["query", "header", "formData", "body", "cookie", "path"]
    | None = None,
    **kwargs: Unpack["SchemaInitKwargs"],
) -> None:
    """Base Parameters.

    Args:
        location (Location, optional): location of the parameters. Defaults to None.
        kwargs (dict): other key word arguments.
    """
    super().__init__(**kwargs)
    self.location: (
        Location
        | Literal["query", "header", "formData", "body", "cookie", "path"]
        | None
    ) = location
    if location is not None:
        self.default_location = Location(location)
    for field in self.fields.values():
        field.load_only = True
        if location is not None:
            if isinstance(location, str):
                location = self.default_location
            set_location(field, location)

Meta ¤

Meta for Parameters.

__contains__ ¤

__contains__(field: str) -> bool

Whether field in self.fields.

Parameters:

Name Type Description Default

field ¤

 str

field name

 required

Returns:

Name Type Description
bool bool

whether field in self.fields
Source code in flask_restx_marshmallow/parameter.py 
 96
 97
 98
 99
100
101
102
103
104
105
def __contains__(self: Self, field: str) -> bool:
    """Whether field in self.fields.

    Args:
        field (str): field name

    Returns:
        bool: whether field in self.fields
    """
    return field in self.fields

__or__ ¤

__or__(other: Parameters) -> Parameters

Combine two schemas.

Parameters:

Name Type Description Default

other ¤

 Self

other schema

 required

Returns:

Name Type Description
Self Parameters

combined schema
Source code in flask_restx_marshmallow/parameter.py 
157
158
159
160
161
162
163
164
165
166
167
168
def __or__(self, other: "Parameters") -> "Parameters":
    """Combine two schemas.

    Args:
        other (Self): other schema

    Returns:
        Self: combined schema
    """
    return self.from_dict(other.fields, name=other.__class__.__name__)(
        location=other.location,
    )

__setitem__ ¤

__setitem__(key: str, value: Field) -> None

Set item.

Source code in flask_restx_marshmallow/parameter.py 
116
117
118
def __setitem__(self: Self, key: str, value: "Field") -> None:
    """Set item."""
    self.fields[key] = value

combine ¤

combine(other: Parameters) -> Parameters

Combine two schemas.

Parameters:

Name Type Description Default

other ¤

 Self

other schema

 required

Returns:

Name Type Description
Self Parameters

combined schema
Source code in flask_restx_marshmallow/parameter.py 
144
145
146
147
148
149
150
151
152
153
154
155
def combine(self: Self, other: "Parameters") -> "Parameters":
    """Combine two schemas.

    Args:
        other (Self): other schema

    Returns:
        Self: combined schema
    """
    return self.from_dict(other.fields, name=other.__class__.__name__)(
        location=other.location,
    )

copy_body_fields ¤

copy_body_fields() -> Parameters

Return a copy of this schema with only fields that location is body.

Source code in flask_restx_marshmallow/parameter.py 
120
121
122
123
124
125
126
127
128
129
130
def copy_body_fields(self: Self) -> "Parameters":
    """Return a copy of this schema with only fields that location is body."""
    return Parameters.from_dict(
        dict(
            filter(
                lambda field: get_location(field[1]) is Location.BODY,
                self.fields.items(),
            ),
        ),
        name=f"{type(self).__name__}Body",
    )(location=Location.BODY)

copy_form_fields ¤

copy_form_fields() -> Parameters

Return a copy of this schema with only fields that location is formdata.

Source code in flask_restx_marshmallow/parameter.py 
132
133
134
135
136
137
138
139
140
141
142
def copy_form_fields(self: Self) -> "Parameters":
    """Return a copy of this schema with only fields that location is formdata."""
    return Parameters.from_dict(
        dict(
            filter(
                lambda field: get_location(field[1]) is Location.FORM_DATA,
                self.fields.items(),
            ),
        ),
        name=f"{type(self).__name__}Form",
    )(location=Location.FORM_DATA)

field_locations ¤

field_locations() -> list[FieldLocations]

Get (field_name, location, is_multiple) for each non-body field.

Returns:

Type Description
list[FieldLocations]

list[FieldLocations]: field name, location, is multiple
Source code in flask_restx_marshmallow/parameter.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
@cached_property
def field_locations(self: Self) -> list[FieldLocations]:
    """Get (field_name, location, is_multiple) for each non-body field.

    Returns:
        list[FieldLocations]: field name, location, is multiple
    """
    return [
        FieldLocations(
            name,
            location or self.default_location,
            isinstance(field, List | Tuple),
        )
        for name, field in self.fields.items()
        if (location := get_location(field)) is not Location.BODY
    ]

items ¤

items() -> Iterable[tuple[str, dict]]

Make dict.

Yields:

Type Description
Iterable[tuple[str, dict]]

tuple[str, dict]: field name and field dict
Source code in flask_restx_marshmallow/parameter.py 
107
108
109
110
111
112
113
114
def items(self: Self) -> "Iterable[tuple[str, dict]]":
    """Make dict.

    Yields:
        tuple[str, dict]: field name and field dict
    """
    for key, value in self.fields.items():
        yield key, value.__dict__

locations ¤

locations() -> set[str]

Get locations.

Returns:

Type Description
set[str]

set[str]: locations
Source code in flask_restx_marshmallow/parameter.py 
67
68
69
70
71
72
73
74
75
76
77
@cached_property
def locations(self: Self) -> set[str]:
    """Get locations.

    Returns:
        set[str]: locations
    """
    return {
        get_location(field) or self.default_location
        for field in self.fields.values()
    }

Request ¤

Bases: Request

The request object that is used by default in this project.

Response ¤

Bases: Response

The response object that is used by default in this project.

ResponseCode ¤

Bases: IntEnum

response code.

ResponseType ¤

Bases: IntEnum

response code.

Result ¤

Result(items: list[T], total: int)

Bases: TypedDict

data.

Source code in flask_restx_marshmallow/type.py 
114
115
@override
def __init__(self, items: list[T], total: int) -> "Result[T]": ...  # type: ignore[override]

Schema ¤

Schema(
    header_fields: Iterable[str] | None = None,
    **kwargs: Unpack[SchemaInitKwargs],
)

Bases: Schema

Response schema.

Response schema.

Parameters:

Name Type Description Default

header_fields ¤

 Iterable[str] | None

fields in response header

 None

kwargs ¤

 Unpack[SchemaInitKwargs]

keyword arguments

 {}
Source code in flask_restx_marshmallow/schema.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def __init__(
    self: Self,
    header_fields: Iterable[str] | None = None,
    **kwargs: Unpack["SchemaInitKwargs"],
) -> None:
    """Response schema.

    Args:
        header_fields (Iterable[str] | None): fields in response header
        kwargs (Unpack["SchemaInitKwargs"]): keyword arguments
    """
    super().__init__(**kwargs)
    self.header_fields = header_fields
    for name, field_obj in self.fields.items():
        if header_fields and name in header_fields:
            cast("dict", field_obj.metadata)["header"] = True
        else:
            field_obj.dump_only = True

example property ¤

example: dict

Example of response schema.

Meta ¤

Meta for response schema.

copy_body_fields ¤

copy_body_fields() -> Schema

Return a copy of this schema with response body fields.

Source code in flask_restx_marshmallow/schema.py 
50
51
52
53
54
55
56
57
58
59
60
61
def copy_body_fields(self: Self) -> "Schema":
    """Return a copy of this schema with response body fields."""
    return Schema.from_dict(
        dict(
            filter(
                lambda field: field[1].metadata.get("header") is not True
                and field[1].metadata.get("simple") is not True,
                self.fields.items(),
            ),
        ),
        name=f"{type(self).__name__}Body",
    )()

copy_header_fields ¤

copy_header_fields() -> Schema

Return a copy of this schema with response header fields.

Source code in flask_restx_marshmallow/schema.py 
63
64
65
66
67
68
69
70
71
72
73
def copy_header_fields(self: Self) -> "Schema":
    """Return a copy of this schema with response header fields."""
    return Schema.from_dict(
        dict(
            filter(
                lambda field: field[1].metadata.get("header") is True,
                self.fields.items(),
            ),
        ),
        name=f"{type(self).__name__}Header",
    )()

copy_simple_string_field ¤

copy_simple_string_field() -> String | None

Return a copy of this schema with simple string fields.

Source code in flask_restx_marshmallow/schema.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
def copy_simple_string_field(self: Self) -> "String | None":
    """Return a copy of this schema with simple string fields."""
    return cast(
        "String | None",
        deepcopy(
            next(
                filter(
                    lambda field: isinstance(field, String)
                    and field.metadata.get("simple") is True,
                    self.fields.values(),
                ),
                None,
            ),
        ),
    )

Success dataclass ¤

Success(
    code: ResponseCode = SUCCESS,
    message: str | None = None,
    result: Result[T] | T | None = None,
)

success response.

Source code in flask_restx_marshmallow/type.py 
161
162
163
164
165
166
167
@override
def __init__(
    self,
    code: ResponseCode = ResponseCode.SUCCESS,
    message: str | None = None,
    result: Result[T] | T | None = None,
) -> "_Success[T]": ...  # type: ignore[override]

__new__ ¤

__new__(
    code: ResponseCode = SUCCESS,
    message: str | None = None,
    result: Result[T] | T | None = None,
) -> _Success[T]

Success response.

Source code in flask_restx_marshmallow/type.py 
146
147
148
149
150
151
152
153
154
155
156
157
def __new__(
    cls,
    code: ResponseCode = ResponseCode.SUCCESS,
    message: str | None = None,
    result: Result[T] | T | None = None,
) -> "_Success[T]":
    """Success response."""
    instance = super().__new__(cls)
    instance.code = code
    instance.message = message
    instance.result = result
    return cast("_Success[T]", filter_none(asdict(instance)))

TupleResponse ¤

Bases: NamedTuple

tuple response.

Warn dataclass ¤

Warn(
    code: ResponseCode = WARNING, message: str | None = None
)

warning response.

Source code in flask_restx_marshmallow/type.py 
232
233
234
235
236
237
@override
def __init__(
    self,
    code: ResponseCode = ResponseCode.WARNING,
    message: str | None = None,
) -> "_Warn": ...  # type: ignore[override]

__new__ ¤

__new__(
    code: ResponseCode = WARNING, message: str | None = None
) -> _Warn

Warning response.

Source code in flask_restx_marshmallow/type.py 
219
220
221
222
223
224
225
226
227
228
def __new__(
    cls,
    code: ResponseCode = ResponseCode.WARNING,
    message: str | None = None,
) -> "_Warn":
    """Warning response."""
    instance = super().__new__(cls)
    instance.code = code
    instance.message = message
    return cast("_Warn", filter_none(asdict(instance)))