flask-marshmallow 1.1.0__py3-none-any.whl

flask_marshmallow/__init__.py

@@ -0,0 +1,128 @@
+"""
+    flask_marshmallow
+    ~~~~~~~~~~~~~~~~~
+
+    Integrates the marshmallow serialization/deserialization library
+    with your Flask application.
+"""
+import typing
+import warnings
+
+from marshmallow import exceptions, pprint
+from marshmallow import fields as base_fields
+
+from . import fields
+from .schema import Schema
+
+if typing.TYPE_CHECKING:
+    from flask import Flask
+
+has_sqla = False
+try:
+    import flask_sqlalchemy  # noqa: F401
+except ImportError:
+    has_sqla = False
+else:
+    try:
+        from . import sqla
+    except ImportError:
+        warnings.warn(
+            "Flask-SQLAlchemy integration requires "
+            "marshmallow-sqlalchemy to be installed.",
+            stacklevel=2,
+        )
+    else:
+        has_sqla = True
+
+__all__ = [
+    "EXTENSION_NAME",
+    "Marshmallow",
+    "Schema",
+    "fields",
+    "exceptions",
+    "pprint",
+]
+
+EXTENSION_NAME = "flask-marshmallow"
+
+
+def _attach_fields(obj):
+    """Attach all the marshmallow fields classes to ``obj``, including
+    Flask-Marshmallow's custom fields.
+    """
+    for attr in base_fields.__all__:
+        if not hasattr(obj, attr):
+            setattr(obj, attr, getattr(base_fields, attr))
+    for attr in fields.__all__:
+        setattr(obj, attr, getattr(fields, attr))
+
+
+class Marshmallow:
+    """Wrapper class that integrates Marshmallow with a Flask application.
+
+    To use it, instantiate with an application::
+
+        from flask import Flask
+
+        app = Flask(__name__)
+        ma = Marshmallow(app)
+
+    The object provides access to the :class:`Schema` class,
+    all fields in :mod:`marshmallow.fields`, as well as the Flask-specific
+    fields in :mod:`flask_marshmallow.fields`.
+
+    You can declare schema like so::
+
+        class BookSchema(ma.Schema):
+            class Meta:
+                fields = ('id', 'title', 'author', 'links')
+
+            author = ma.Nested(AuthorSchema)
+
+            links = ma.Hyperlinks({
+                'self': ma.URLFor('book_detail', values=dict(id='<id>')),
+                'collection': ma.URLFor('book_list')
+            })
+
+
+    In order to integrate with Flask-SQLAlchemy, this extension must be initialized
+    *after* `flask_sqlalchemy.SQLAlchemy`. ::
+
+            db = SQLAlchemy(app)
+            ma = Marshmallow(app)
+
+    This gives you access to `ma.SQLAlchemySchema` and `ma.SQLAlchemyAutoSchema`, which
+    generate marshmallow `~marshmallow.Schema` classes
+    based on the passed in model or table. ::
+
+        class AuthorSchema(ma.SQLAlchemyAutoSchema):
+            class Meta:
+                model = Author
+
+    :param Flask app: The Flask application object.
+    """
+
+    def __init__(self, app: typing.Optional["Flask"] = None):
+        self.Schema = Schema
+        if has_sqla:
+            self.SQLAlchemySchema = sqla.SQLAlchemySchema
+            self.SQLAlchemyAutoSchema = sqla.SQLAlchemyAutoSchema
+            self.auto_field = sqla.auto_field
+            self.HyperlinkRelated = sqla.HyperlinkRelated
+        _attach_fields(self)
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: "Flask"):
+        """Initializes the application with the extension.
+
+        :param Flask app: The Flask application object.
+        """
+        app.extensions = getattr(app, "extensions", {})
+
+        # If using Flask-SQLAlchemy, attach db.session to SQLAlchemySchema
+        if has_sqla and "sqlalchemy" in app.extensions:
+            db = app.extensions["sqlalchemy"]
+            self.SQLAlchemySchema.OPTIONS_CLASS.session = db.session
+            self.SQLAlchemyAutoSchema.OPTIONS_CLASS.session = db.session
+        app.extensions[EXTENSION_NAME] = self

flask_marshmallow/fields.py

@@ -0,0 +1,260 @@
+"""
+    flask_marshmallow.fields
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Custom, Flask-specific fields.
+
+    See the `marshmallow.fields` module for the list of all fields available from the
+    marshmallow library.
+"""
+import re
+import typing
+
+from flask import current_app, url_for
+from marshmallow import fields, missing
+
+__all__ = [
+    "URLFor",
+    "UrlFor",
+    "AbsoluteURLFor",
+    "AbsoluteUrlFor",
+    "Hyperlinks",
+    "File",
+    "Config",
+]
+
+
+_tpl_pattern = re.compile(r"\s*<\s*(\S*)\s*>\s*")
+
+
+def _tpl(val: str) -> typing.Optional[str]:
+    """Return value within ``< >`` if possible, else return ``None``."""
+    match = _tpl_pattern.match(val)
+    if match:
+        return match.groups()[0]
+    return None
+
+
+def _get_value(obj, key, default=missing):
+    """Slightly-modified version of marshmallow.utils.get_value.
+    If a dot-delimited ``key`` is passed and any attribute in the
+    path is `None`, return `None`.
+    """
+    if "." in key:
+        return _get_value_for_keys(obj, key.split("."), default)
+    else:
+        return _get_value_for_key(obj, key, default)
+
+
+def _get_value_for_keys(obj, keys, default):
+    if len(keys) == 1:
+        return _get_value_for_key(obj, keys[0], default)
+    else:
+        value = _get_value_for_key(obj, keys[0], default)
+        # XXX This differs from the marshmallow implementation
+        if value is None:
+            return None
+        return _get_value_for_keys(value, keys[1:], default)
+
+
+def _get_value_for_key(obj, key, default):
+    if not hasattr(obj, "__getitem__"):
+        return getattr(obj, key, default)
+
+    try:
+        return obj[key]
+    except (KeyError, IndexError, TypeError, AttributeError):
+        return getattr(obj, key, default)
+
+
+class URLFor(fields.Field):
+    """Field that outputs the URL for an endpoint. Acts identically to
+    Flask's ``url_for`` function, except that arguments can be pulled from the
+    object to be serialized, and ``**values`` should be passed to the ``values``
+    parameter.
+
+    Usage: ::
+
+        url = URLFor('author_get', values=dict(id='<id>'))
+        https_url = URLFor(
+            'author_get',
+            values=dict(id='<id>', _scheme='https', _external=True),
+        )
+
+    :param str endpoint: Flask endpoint name.
+    :param dict values: Same keyword arguments as Flask's url_for, except string
+        arguments enclosed in `< >` will be interpreted as attributes to pull
+        from the object.
+    :param kwargs: keyword arguments to pass to marshmallow field (e.g. ``required``).
+    """
+
+    _CHECK_ATTRIBUTE = False
+
+    def __init__(
+        self,
+        endpoint: str,
+        values: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        **kwargs,
+    ):
+        self.endpoint = endpoint
+        self.values = values or {}
+        fields.Field.__init__(self, **kwargs)
+
+    def _serialize(self, value, key, obj):
+        """Output the URL for the endpoint, given the kwargs passed to
+        ``__init__``.
+        """
+        param_values = {}
+        for name, attr_tpl in self.values.items():
+            attr_name = _tpl(str(attr_tpl))
+            if attr_name:
+                attribute_value = _get_value(obj, attr_name, default=missing)
+                if attribute_value is None:
+                    return None
+                if attribute_value is not missing:
+                    param_values[name] = attribute_value
+                else:
+                    raise AttributeError(
+                        f"{attr_name!r} is not a valid " f"attribute of {obj!r}"
+                    )
+            else:
+                param_values[name] = attr_tpl
+        return url_for(self.endpoint, **param_values)
+
+
+UrlFor = URLFor
+
+
+class AbsoluteURLFor(URLFor):
+    """Field that outputs the absolute URL for an endpoint."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        values: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        **kwargs,
+    ):
+        if values:
+            values["_external"] = True
+        else:
+            values = {"_external": True}
+        URLFor.__init__(self, endpoint=endpoint, values=values, **kwargs)
+
+
+AbsoluteUrlFor = AbsoluteURLFor
+
+
+def _rapply(
+    d: typing.Union[dict, typing.Iterable], func: typing.Callable, *args, **kwargs
+):
+    """Apply a function to all values in a dictionary or
+    list of dictionaries, recursively.
+    """
+    if isinstance(d, (tuple, list)):
+        return [_rapply(each, func, *args, **kwargs) for each in d]
+    if isinstance(d, dict):
+        return {key: _rapply(value, func, *args, **kwargs) for key, value in d.items()}
+    else:
+        return func(d, *args, **kwargs)
+
+
+def _url_val(val: typing.Any, key: str, obj: typing.Any, **kwargs):
+    """Function applied by `HyperlinksField` to get the correct value in the
+    schema.
+    """
+    if isinstance(val, URLFor):
+        return val.serialize(key, obj, **kwargs)
+    else:
+        return val
+
+
+class Hyperlinks(fields.Field):
+    """Field that outputs a dictionary of hyperlinks,
+    given a dictionary schema with :class:`~flask_marshmallow.fields.URLFor`
+    objects as values.
+
+    Example: ::
+
+        _links = Hyperlinks({
+            'self': URLFor('author', values=dict(id='<id>')),
+            'collection': URLFor('author_list'),
+        })
+
+    `URLFor` objects can be nested within the dictionary. ::
+
+        _links = Hyperlinks({
+            'self': {
+                'href': URLFor('book', values=dict(id='<id>')),
+                'title': 'book detail'
+            }
+        })
+
+    :param dict schema: A dict that maps names to
+        :class:`~flask_marshmallow.fields.URLFor` fields.
+    """
+
+    _CHECK_ATTRIBUTE = False
+
+    def __init__(self, schema: typing.Dict[str, typing.Union[URLFor, str]], **kwargs):
+        self.schema = schema
+        fields.Field.__init__(self, **kwargs)
+
+    def _serialize(self, value, attr, obj):
+        return _rapply(self.schema, _url_val, key=attr, obj=obj)
+
+
+class File(fields.Field):
+    """A binary file field for uploaded files.
+
+    Examples: ::
+
+        class ImageSchema(Schema):
+            image = File(required=True)
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Metadata used by apispec
+        self.metadata["type"] = "string"
+        self.metadata["format"] = "binary"
+
+    default_error_messages = {"invalid": "Not a valid file."}
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        from werkzeug.datastructures import FileStorage
+
+        if not isinstance(value, FileStorage):
+            raise self.make_error("invalid")
+        return value
+
+
+class Config(fields.Field):
+    """A field for Flask configuration values.
+
+    Examples: ::
+
+        from flask import Flask
+
+        app = Flask(__name__)
+        app.config['API_TITLE'] = 'Pet API'
+
+        class FooSchema(Schema):
+            user = String()
+            title = Config('API_TITLE')
+
+    This field should only be used in an output schema. A ``ValueError`` will
+    be raised if the config key is not found in the app config.
+
+    :param str key: The key of the configuration value.
+    """
+
+    _CHECK_ATTRIBUTE = False
+
+    def __init__(self, key: str, **kwargs):
+        fields.Field.__init__(self, **kwargs)
+        self.key = key
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        if self.key not in current_app.config:
+            raise ValueError(f"The key {self.key!r} is not found in the app config.")
+        return current_app.config[self.key]

flask_marshmallow/schema.py

@@ -0,0 +1,41 @@
+import typing
+
+import flask
+import marshmallow as ma
+
+if typing.TYPE_CHECKING:
+    from flask.wrappers import Response
+
+
+class Schema(ma.Schema):
+    """Base serializer with which to define custom serializers.
+
+    See `marshmallow.Schema` for more details about the `Schema` API.
+    """
+
+    def jsonify(
+        self, obj: typing.Any, many: typing.Optional[bool] = None, *args, **kwargs
+    ) -> "Response":
+        """Return a JSON response containing the serialized data.
+
+
+        :param obj: Object to serialize.
+        :param bool many: Whether `obj` should be serialized as an instance
+            or as a collection. If None, defaults to the value of the
+            `many` attribute on this Schema.
+        :param kwargs: Additional keyword arguments passed to `flask.jsonify`.
+
+        .. versionchanged:: 0.6.0
+            Takes the same arguments as `marshmallow.Schema.dump`. Additional
+            keyword arguments are passed to `flask.jsonify`.
+
+        .. versionchanged:: 0.6.3
+            The `many` argument for this method defaults to the value of
+            the `many` attribute on the Schema. Previously, the `many`
+            argument of this method defaulted to False, regardless of the
+            value of `Schema.many`.
+        """
+        if many is None:
+            many = self.many
+        data = self.dump(obj, many=many)
+        return flask.jsonify(data, *args, **kwargs)

flask_marshmallow/sqla.py

@@ -0,0 +1,123 @@
+"""
+    flask_marshmallow.sqla
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Integration with Flask-SQLAlchemy and marshmallow-sqlalchemy. Provides
+    `SQLAlchemySchema <marshmallow_sqlalchemy.SQLAlchemySchema>` and
+    `SQLAlchemyAutoSchema <marshmallow_sqlalchemy.SQLAlchemyAutoSchema>` classes
+    that use the scoped session from Flask-SQLAlchemy.
+"""
+from urllib import parse
+
+import marshmallow_sqlalchemy as msqla
+from flask import current_app, url_for
+from marshmallow.exceptions import ValidationError
+
+from .schema import Schema
+
+
+class DummySession:
+    """Placeholder session object."""
+
+    pass
+
+
+class FlaskSQLAlchemyOptsMixin:
+    session = DummySession()
+
+    def __init__(self, meta, **kwargs):
+        if not hasattr(meta, "sqla_session"):
+            meta.sqla_session = self.session
+        super().__init__(meta, **kwargs)
+
+
+# SQLAlchemySchema and SQLAlchemyAutoSchema are available in newer ma-sqla versions
+if hasattr(msqla, "SQLAlchemySchema"):
+
+    class SQLAlchemySchemaOpts(FlaskSQLAlchemyOptsMixin, msqla.SQLAlchemySchemaOpts):
+        pass
+
+    class SQLAlchemySchema(msqla.SQLAlchemySchema, Schema):
+        """SQLAlchemySchema that associates a schema with a model via the
+        `model` class Meta option, which should be a
+        ``db.Model`` class from `flask_sqlalchemy`. Uses the
+        scoped session from Flask-SQLAlchemy by default.
+
+        See `marshmallow_sqlalchemy.SQLAlchemySchema` for more details
+        on the `SQLAlchemySchema` API.
+        """
+
+        OPTIONS_CLASS = SQLAlchemySchemaOpts
+
+else:
+    SQLAlchemySchema = None  # type: ignore
+
+if hasattr(msqla, "SQLAlchemyAutoSchema"):
+
+    class SQLAlchemyAutoSchemaOpts(
+        FlaskSQLAlchemyOptsMixin, msqla.SQLAlchemyAutoSchemaOpts
+    ):
+        pass
+
+    class SQLAlchemyAutoSchema(msqla.SQLAlchemyAutoSchema, Schema):
+        """SQLAlchemyAutoSchema that automatically generates marshmallow fields
+        from a SQLAlchemy model's or table's column.
+        Uses the scoped session from Flask-SQLAlchemy by default.
+
+        See `marshmallow_sqlalchemy.SQLAlchemyAutoSchema` for more details
+        on the `SQLAlchemyAutoSchema` API.
+        """
+
+        OPTIONS_CLASS = SQLAlchemyAutoSchemaOpts
+
+else:
+    SQLAlchemyAutoSchema = None  # type: ignore
+
+auto_field = getattr(msqla, "auto_field", None)
+
+
+class HyperlinkRelated(msqla.fields.Related):
+    """Field that generates hyperlinks to indicate references between models,
+    rather than primary keys.
+
+    :param str endpoint: Flask endpoint name for generated hyperlink.
+    :param str url_key: The attribute containing the reference's primary
+        key. Defaults to "id".
+    :param bool external: Set to `True` if absolute URLs should be used,
+        instead of relative URLs.
+    """
+
+    def __init__(
+        self, endpoint: str, url_key: str = "id", external: bool = False, **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.endpoint = endpoint
+        self.url_key = url_key
+        self.external = external
+
+    def _serialize(self, value, attr, obj):
+        if value is None:
+            return None
+        key = super()._serialize(value, attr, obj)
+        kwargs = {self.url_key: key}
+        return url_for(self.endpoint, _external=self.external, **kwargs)
+
+    def _deserialize(self, value, *args, **kwargs):
+        if self.external:
+            parsed = parse.urlparse(value)
+            value = parsed.path
+        endpoint, kwargs = self.adapter.match(value)
+        if endpoint != self.endpoint:
+            raise ValidationError(
+                f'Parsed endpoint "{endpoint}" from URL "{value}"; expected '
+                f'"{self.endpoint}"'
+            )
+        if self.url_key not in kwargs:
+            raise ValidationError(
+                f'URL pattern "{self.url_key}" not found in {kwargs!r}'
+            )
+        return super()._deserialize(kwargs[self.url_key], *args, **kwargs)
+
+    @property
+    def adapter(self):
+        return current_app.url_map.bind("")

flask_marshmallow/validate.py

@@ -0,0 +1,183 @@
+"""
+    flask_marshmallow.validate
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Custom validation classes for various types of data.
+"""
+import os
+import re
+import typing
+
+from marshmallow.exceptions import ValidationError
+from marshmallow.validate import Validator as Validator
+from werkzeug.datastructures import FileStorage
+
+
+def _get_filestorage_size(file):
+    """Return the size of the FileStorage object in bytes."""
+    size = len(file.read())
+    file.stream.seek(0)
+    return size
+
+
+# This function is copied from loguru with few modifications.
+# https://github.com/Delgan/loguru/blob/master/loguru/_string_parsers.py#L35
+def _parse_size(size: str) -> float:
+    """Return the value which the ``size`` represents in bytes."""
+    size = size.strip()
+    reg = re.compile(r"([e\+\-\.\d]+)\s*([kmgtpezy])?(i)?(b)", flags=re.I)
+
+    match = reg.fullmatch(size)
+
+    if not match:
+        raise ValueError(f"Invalid size value: '{size!r}'")
+
+    s, u, i, b = match.groups()
+
+    try:
+        s = float(s)
+    except ValueError as e:
+        raise ValueError(f"Invalid float value while parsing size: '{s!r}'") from e
+
+    u = "kmgtpezy".index(u.lower()) + 1 if u else 0
+    i = 1024 if i else 1000
+    b = {"b": 8, "B": 1}[b] if b else 1
+    return s * i**u / b
+
+
+class FileSize(Validator):
+    """Validator which succeeds if the file passed to it is within the specified
+    size range. If ``min`` is not specified, or is specified as `None`,
+    no lower bound exists. If ``max`` is not specified, or is specified as `None`,
+    no upper bound exists. The inclusivity of the bounds (if they exist)
+    is configurable.
+    If ``min_inclusive`` is not specified, or is specified as `True`, then
+    the ``min`` bound is included in the range. If ``max_inclusive`` is not specified,
+    or is specified as `True`, then the ``max`` bound is included in the range.
+
+    Example: ::
+
+        class ImageSchema(Schema):
+            image = File(required=True, validate=FileSize(min='1 MiB', max='2 MiB'))
+
+    :param min: The minimum size (lower bound). If not provided, minimum
+        size will not be checked.
+    :param max: The maximum size (upper bound). If not provided, maximum
+        size will not be checked.
+    :param min_inclusive: Whether the ``min`` bound is included in the range.
+    :param max_inclusive: Whether the ``max`` bound is included in the range.
+    :param error: Error message to raise in case of a validation error.
+        Can be interpolated with `{input}`, `{min}` and `{max}`.
+    """
+
+    message_min = "Must be {min_op} {{min}}."
+    message_max = "Must be {max_op} {{max}}."
+    message_all = "Must be {min_op} {{min}} and {max_op} {{max}}."
+
+    message_gte = "greater than or equal to"
+    message_gt = "greater than"
+    message_lte = "less than or equal to"
+    message_lt = "less than"
+
+    def __init__(
+        self,
+        min: typing.Optional[str] = None,
+        max: typing.Optional[str] = None,
+        min_inclusive: bool = True,
+        max_inclusive: bool = True,
+        error: typing.Optional[str] = None,
+    ):
+        self.min = min
+        self.max = max
+        self.min_size = _parse_size(self.min) if self.min else None
+        self.max_size = _parse_size(self.max) if self.max else None
+        self.min_inclusive = min_inclusive
+        self.max_inclusive = max_inclusive
+        self.error = error
+
+        self.message_min = self.message_min.format(
+            min_op=self.message_gte if self.min_inclusive else self.message_gt
+        )
+        self.message_max = self.message_max.format(
+            max_op=self.message_lte if self.max_inclusive else self.message_lt
+        )
+        self.message_all = self.message_all.format(
+            min_op=self.message_gte if self.min_inclusive else self.message_gt,
+            max_op=self.message_lte if self.max_inclusive else self.message_lt,
+        )
+
+    def _repr_args(self):
+        return "min={!r}, max={!r}, min_inclusive={!r}, max_inclusive={!r}".format(
+            self.min, self.max, self.min_inclusive, self.max_inclusive
+        )
+
+    def _format_error(self, value, message):
+        return (self.error or message).format(input=value, min=self.min, max=self.max)
+
+    def __call__(self, value):
+        if not isinstance(value, FileStorage):
+            raise TypeError(
+                f"A FileStorage object is required, not {type(value).__name__!r}"
+            )
+
+        file_size = _get_filestorage_size(value)
+        if self.min_size is not None and (
+            file_size < self.min_size
+            if self.min_inclusive
+            else file_size <= self.min_size
+        ):
+            message = self.message_min if self.max is None else self.message_all
+            raise ValidationError(self._format_error(value, message))
+
+        if self.max_size is not None and (
+            file_size > self.max_size
+            if self.max_inclusive
+            else file_size >= self.max_size
+        ):
+            message = self.message_max if self.min is None else self.message_all
+            raise ValidationError(self._format_error(value, message))
+
+        return value
+
+
+class FileType(Validator):
+    """Validator which succeeds if the uploaded file is allowed by a given list
+        of extensions.
+
+    Example: ::
+        class ImageSchema(Schema):
+            image = File(required=True, validate=FileType(['.png']))
+
+    :param accept: A sequence of allowed extensions.
+    :param error: Error message to raise in case of a validation error.
+        Can be interpolated with ``{input}`` and ``{extensions}``.
+    """
+
+    default_message = "Not an allowed file type. Allowed file types: [{extensions}]"
+
+    def __init__(
+        self,
+        accept: typing.Iterable[str],
+        error: typing.Optional[str] = None,
+    ):
+        self.allowed_types = {ext.lower() for ext in accept}
+        self.error = error or self.default_message
+
+    def _format_error(self, value):
+        return (self.error or self.default_message).format(
+            input=value, extensions="".join(self.allowed_types)
+        )
+
+    def __call__(self, value):
+        if not isinstance(value, FileStorage):
+            raise TypeError(
+                f"A FileStorage object is required, not {type(value).__name__!r}"
+            )
+
+        _, extension = (
+            os.path.splitext(value.filename) if value.filename else (None, None)
+        )
+        if extension is None or extension.lower() not in self.allowed_types:
+            raise ValidationError(self._format_error(value))
+
+        return value

flask_marshmallow-1.1.0.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2014-2024 Steven Loria and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

flask_marshmallow-1.1.0.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: flask-marshmallow
+Version: 1.1.0
+Summary: Flask + marshmallow for beautiful APIs
+Maintainer-email: Steven Loria <sloria1@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Dist: Flask>=2.2
+Requires-Dist: marshmallow>=3.0.0
+Requires-Dist: flask-marshmallow[tests] ; extra == "dev"
+Requires-Dist: tox ; extra == "dev"
+Requires-Dist: pre-commit~=3.5 ; extra == "dev"
+Requires-Dist: marshmallow-sqlalchemy>=0.19.0 ; extra == "docs"
+Requires-Dist: Sphinx==7.2.6 ; extra == "docs"
+Requires-Dist: sphinx-issues==3.0.1 ; extra == "docs"
+Requires-Dist: flask-sqlalchemy>=3.0.0 ; extra == "sqlalchemy"
+Requires-Dist: marshmallow-sqlalchemy>=0.29.0 ; extra == "sqlalchemy"
+Requires-Dist: flask-marshmallow[sqlalchemy] ; extra == "tests"
+Requires-Dist: pytest ; extra == "tests"
+Project-URL: Funding, https://opencollective.com/marshmallow
+Project-URL: Issues, https://github.com/marshmallow-code/flask-marshmallow/issues
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: sqlalchemy
+Provides-Extra: tests
+
+*****************
+Flask-Marshmallow
+*****************
+
+|pypi-package| |build-status| |docs| |marshmallow3|
+
+Flask + marshmallow for beautiful APIs
+======================================
+
+Flask-Marshmallow is a thin integration layer for `Flask`_ (a Python web framework) and `marshmallow`_ (an object serialization/deserialization library) that adds additional features to marshmallow, including URL and Hyperlinks fields for HATEOAS-ready APIs. It also (optionally) integrates with `Flask-SQLAlchemy <http://flask-sqlalchemy.pocoo.org/>`_.
+
+Get it now
+----------
+::
+
+    pip install flask-marshmallow
+
+
+Create your app.
+
+.. code-block:: python
+
+    from flask import Flask
+    from flask_marshmallow import Marshmallow
+
+    app = Flask(__name__)
+    ma = Marshmallow(app)
+
+Write your models.
+
+.. code-block:: python
+
+    from your_orm import Model, Column, Integer, String, DateTime
+
+
+    class User(Model):
+        email = Column(String)
+        password = Column(String)
+        date_created = Column(DateTime, auto_now_add=True)
+
+
+Define your output format with marshmallow.
+
+.. code-block:: python
+
+
+    class UserSchema(ma.Schema):
+        class Meta:
+            # Fields to expose
+            fields = ("email", "date_created", "_links")
+
+        # Smart hyperlinking
+        _links = ma.Hyperlinks(
+            {
+                "self": ma.URLFor("user_detail", values=dict(id="<id>")),
+                "collection": ma.URLFor("users"),
+            }
+        )
+
+
+    user_schema = UserSchema()
+    users_schema = UserSchema(many=True)
+
+
+Output the data in your views.
+
+.. code-block:: python
+
+    @app.route("/api/users/")
+    def users():
+        all_users = User.all()
+        return users_schema.dump(all_users)
+
+
+    @app.route("/api/users/<id>")
+    def user_detail(id):
+        user = User.get(id)
+        return user_schema.dump(user)
+
+
+    # {
+    #     "email": "fred@queen.com",
+    #     "date_created": "Fri, 25 Apr 2014 06:02:56 -0000",
+    #     "_links": {
+    #         "self": "/api/users/42",
+    #         "collection": "/api/users/"
+    #     }
+    # }
+
+
+http://flask-marshmallow.readthedocs.io/
+========================================
+
+Learn More
+==========
+
+To learn more about marshmallow, check out its `docs <http://marshmallow.readthedocs.io/en/latest/>`_.
+
+
+
+Project Links
+=============
+
+- Docs: https://flask-marshmallow.readthedocs.io/
+- Changelog: http://flask-marshmallow.readthedocs.io/en/latest/changelog.html
+- PyPI: https://pypi.org/project/flask-marshmallow/
+- Issues: https://github.com/marshmallow-code/flask-marshmallow/issues
+
+License
+=======
+
+MIT licensed. See the bundled `LICENSE <https://github.com/marshmallow-code/flask-marshmallow/blob/master/LICENSE>`_ file for more details.
+
+
+.. _Flask: http://flask.pocoo.org
+.. _marshmallow: http://marshmallow.readthedocs.io
+
+.. |pypi-package| image:: https://badgen.net/pypi/v/flask-marshmallow
+    :target: https://pypi.org/project/flask-marshmallow/
+    :alt: Latest version
+
+.. |build-status| image:: https://github.com/marshmallow-code/flask-marshmallow/actions/workflows/build-release.yml/badge.svg
+    :target: https://github.com/marshmallow-code/flask-marshmallow/actions/workflows/build-release.yml
+    :alt: Build status
+
+.. |docs| image:: https://readthedocs.org/projects/flask-marshmallow/badge/
+   :target: https://flask-marshmallow.readthedocs.io/
+   :alt: Documentation
+
+.. |marshmallow3| image:: https://badgen.net/badge/marshmallow/3
+    :target: https://marshmallow.readthedocs.io/en/latest/upgrading.html
+    :alt: marshmallow 3 compatible
+

flask_marshmallow-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+flask_marshmallow/__init__.py,sha256=2s46vkrP0wX1wXBT0OF9oTUNIaoX5-uu_AogfhGXupg,3650
+flask_marshmallow/fields.py,sha256=0_mk3dKpyDKT66Tp4KoDZ0uNCxmvGVH3Rk4OAwjR8f4,7486
+flask_marshmallow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_marshmallow/schema.py,sha256=Z6uJVkqi-gq1QfdPbPuy5Fw3UnXGE9vKiD6IJkPOMR4,1412
+flask_marshmallow/sqla.py,sha256=QKEpKDfrBJ5m1KpnRuEB5Txfxql-aN_pyHznYxzNd6Y,3971
+flask_marshmallow/validate.py,sha256=ysyVujOIT-mM4A6DJyoIQNXJBxYpWmcaQVbpu-JZhV8,6534
+flask_marshmallow-1.1.0.dist-info/LICENSE,sha256=H-cSJC-pIkSF8BRLl27SpHZOUglXoFxnuVdBE2NO50c,1074
+flask_marshmallow-1.1.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+flask_marshmallow-1.1.0.dist-info/METADATA,sha256=S_tnxO-oXSl3sP8iTP52pB6aKk-ssx08KZoPVXf9MC0,5154
+flask_marshmallow-1.1.0.dist-info/RECORD,,

flask_marshmallow-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any