marshmallow_dataclass
Automatic generation of marshmallow schemas from dataclasses.
Specifying a schema to which your data should conform is very useful, both for (de)serialization and for documentation. However, using schemas in python often means having both a class to represent your data and a class to represent its schema, which means duplicated code that could fall out of sync. With the new features of python 3.6, types can be defined for class members, and that allows libraries like this one to generate schemas automatically.
An use case would be to document APIs (with flasgger, for instance) in a way that allows you to statically check that the code matches the documentation.
How to use
You simply import
marshmallow_dataclass.dataclass
instead of
dataclasses.dataclass.
It adds a Schema property to the generated class,
containing a marshmallow
Schema
class.
If you need to specify custom properties on your marshmallow fields
(such as attribute, error, validate, required, dump_only, error_messages, description ...)
you can add them using the metadata argument of the
field
function.
from dataclasses import field
from marshmallow_dataclass import dataclass # Importing from marshmallow_dataclass instead of dataclasses
import marshmallow.validate
from typing import List, Optional
@dataclass
class Building:
# The field metadata is used to instantiate the marshmallow field
height: float = field(metadata={'validate': marshmallow.validate.Range(min=0)})
name: str = field(default="anonymous")
@dataclass
class City:
name: Optional[str]
buildings: List[Building] = field(default_factory=lambda: [])
# City.Schema contains a marshmallow schema class
city, _ = City.Schema().load({
"name": "Paris",
"buildings": [
{"name": "Eiffel Tower", "height":324}
]
})
# Serializing city as a json string
city_json, _ = City.Schema().dumps(city)
The previous syntax is very convenient, as the only change
you have to apply to your existing code is update the
dataclass import.
However, as the .Schema property is added dynamically,
it can confuse type checkers.
If you want to avoid that, you can also use the standard
dataclass decorator, and generate the schema manually
using
class_schema
:
from dataclasses import dataclass
from datetime import datetime
import marshmallow_dataclass
@dataclass
class Person:
name: str
birth: datetime
PersonSchema = marshmallow_dataclass.class_schema(Person)
You can also declare the schema as a
ClassVar:
from marshmallow_dataclass import dataclass
from marshmallow import Schema
from typing import ClassVar, Type
@dataclass
class Point:
x:float
y:float
Schema: ClassVar[Type[Schema]] = Schema
You can specify the
Meta
just as you would in a marshmallow Schema:
from marshmallow_dataclass import dataclass
@dataclass
class Point:
x:float
y:float
class Meta:
ordered = True
Installation
This package is hosted on pypi :
pipenv install marshmallow-dataclass
Documentation
The project documentation is hosted on github pages:
Usage warning
This library depends on python's standard typing library, which is provisional.
1 maintainer
Metadata
1 maintainer
Release files for marshmallow-dataclass 0.6.4
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | |
|---|---|---|---|
| marshmallow_dataclass-0.6.4.tar.gz | 6.8 kB | Details |
Release files / marshmallow_dataclass-0.6.4.tar.gz
| Download URL | marshmallow_dataclass-0.6.4.tar.gz |
|---|---|
| Size | 6.8 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
3054454a520e0a30b04027a4d892c17c64787c30dbceda81d2a3ca4e06c5d73a
|
|
BLAKE2b-256 checksum How to use checksums |
ffe35bc89432ffdcbef37452ae088cbf4cc4f4630d112fe5b4fd0dfdd676cbaf
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/1.13.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/41.0.1 requests-toolbelt/0.9.1 tqdm/4.32.1 CPython/3.7.1
|
