Marshalling and Serialising views¶
Introduction¶
LabThings makes use of the Marshmallow library for both response and argument marshaling. From the Marshmallow documentation:
marshmallow is an ORM/ODM/framework-agnostic library for converting complex datatypes, such as objects, to and from native Python datatypes.
In short, marshmallow schemas can be used to:
Validate input data.
Deserialize input data to app-level objects.
Serialize app-level objects to primitive Python types. The serialized objects can then be rendered to standard formats such as JSON for use in an HTTP API.
Marshalling schemas are used by LabThings to document the data types of properties, as well as the structure and types of Action arguments and return values. They allow arbitrary Python objects to be returned as serialized JSON, and ensure that input arguments are properly formated before being passed to your Python functions.
From our quickstart example, we use schemas for our integration_time property to inform LabThings that both responses and requests to the API should be integer formatted. Additional information about range, example values, and units can be added to the schema field.
labthing.build_property(
my_spectrometer, # Python object
"integration_time", # Objects attribute name
description="Single-shot integration time",
schema=fields.Int(min=100, max=500, example=200, unit="microsecond")
)
Actions require separate schemas for input and output, since the action return data is likely in a different format to the input arguments. In our quickstart example, our schema argument informs LabThings that the action return value should be a list of numbers. Meanwhile, our args argument informs LabThings that requests to start the action should include an attribute called n, which should be an integer. Human-readable descriptions, examples, and default values can be added to the args field.
labthing.build_action(
my_spectrometer, # Python object
"average_data", # Objects method name
description="Take an averaged measurement",
schema=fields.List(fields.Number()),
args={ # How do we convert from the request input to function arguments?
"n": fields.Int(description="Number of averages to take", example=5, default=5)
},
)
Schemas¶
A schema is a collection of keys and fields describing how an object should be serialized/deserialized. Schemas can be created in several ways, either by creating a labthings.Schema
class, or by passing a dictionary of key-field pairs.
Note that the labthings.Schema
class is an alias of marshmallow.Schema
, and the two can be used interchangeably.
Schemas are required for argument parsing. While Property views can be marshalled with a single field, arguments must be passed to the server as a JSON object, which gets mapped to a Python dictionary and passed to the Action method.
For example, a Python function of the form:
from typing import List
def my_function(quantity: int, name: str, organizations: List(str)):
return quantity * len(organizations)
would require args of the form:
args = {
"quantity": fields.Int()
"name": fields.String()
"organisation": fields.List(fields.String())
}
and a schema of labthings.fields.Int
.
Fields¶
Most data types are represented by fields in the Marshmallow library. All Marshmallow fields are imported and available from the labthings.fields
submodule, however any field can be imported from Marshmallow and used in LabThings schemas.
- class labthings.fields.AwareDateTime(format: Optional[str] = None, *, default_timezone: Optional[datetime.tzinfo] = None, **kwargs)¶
A formatted aware datetime string.
- Parameters
New in version 3.0.0rc9.
- AWARENESS = 'aware'¶
- labthings.fields.Bool¶
alias of
marshmallow.fields.Boolean
- class labthings.fields.Boolean(*, truthy: Optional[Set] = None, falsy: Optional[Set] = None, **kwargs)¶
A boolean field.
- Parameters
truthy – Values that will (de)serialize to True. If an empty set, any non-falsy value will deserialize to True. If None, marshmallow.fields.Boolean.truthy will be used.
falsy – Values that will (de)serialize to False. If None, marshmallow.fields.Boolean.falsy will be used.
kwargs – The same keyword arguments that
Field
receives.
- default_error_messages = {'invalid': 'Not a valid boolean.'}¶
Default error messages.
- falsy = {'false', 0, 'no', 'False', 'F', 'Off', 'No', 'FALSE', 'off', 'OFF', 'N', 'f', 'NO', 'n', '0'}¶
Default falsy values.
- truthy = {'Yes', 1, 'True', '1', 'true', 'Y', 'On', 't', 'ON', 'y', 'yes', 'T', 'YES', 'TRUE', 'on'}¶
Default truthy values.
- class labthings.fields.Bytes(*, load_default: Any = <marshmallow.missing>, missing: Any = <marshmallow.missing>, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, data_key: Optional[str] = None, attribute: Optional[str] = None, validate: Optional[Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]] = None, required: bool = False, allow_none: Optional[bool] = None, load_only: bool = False, dump_only: bool = False, error_messages: Optional[Dict[str, str]] = None, metadata: Optional[Mapping[str, Any]] = None, **additional_metadata)¶
Marshmallow field for bytes objects
- class labthings.fields.Constant(constant: Any, **kwargs)¶
A field that (de)serializes to a preset constant. If you only want the constant added for serialization or deserialization, you should use
dump_only=True
orload_only=True
respectively.- Parameters
constant – The constant to return for the field attribute.
New in version 2.0.0.
- class labthings.fields.Date(format: Optional[str] = None, **kwargs)¶
ISO8601-formatted date string.
- Parameters
format – Either
"iso"
(for ISO8601) or a date format string. If None, defaults to “iso”.kwargs – The same keyword arguments that
Field
receives.
- DEFAULT_FORMAT = 'iso'¶
- DESERIALIZATION_FUNCS: Dict[str, Callable[[str], Any]] = {'iso': <function from_iso_date>, 'iso8601': <function from_iso_date>}¶
- OBJ_TYPE = 'date'¶
- SCHEMA_OPTS_VAR_NAME = 'dateformat'¶
- SERIALIZATION_FUNCS: Dict[str, Callable[[Any], str]] = {'iso': <function to_iso_date>, 'iso8601': <function to_iso_date>}¶
- default_error_messages = {'format': '"{input}" cannot be formatted as a date.', 'invalid': 'Not a valid date.'}¶
Default error messages.
- class labthings.fields.DateTime(format: Optional[str] = None, **kwargs)¶
A formatted datetime string.
Example:
'2014-12-22T03:12:58.019077+00:00'
- Parameters
format – Either
"rfc"
(for RFC822),"iso"
(for ISO8601), or a date format string. If None, defaults to “iso”.kwargs – The same keyword arguments that
Field
receives.
Changed in version 3.0.0rc9: Does not modify timezone information on (de)serialization.
- DEFAULT_FORMAT = 'iso'¶
- DESERIALIZATION_FUNCS: Dict[str, Callable[[str], Any]] = {'iso': <function from_iso_datetime>, 'iso8601': <function from_iso_datetime>, 'rfc': <function from_rfc>, 'rfc822': <function from_rfc>}¶
- OBJ_TYPE = 'datetime'¶
- SCHEMA_OPTS_VAR_NAME = 'datetimeformat'¶
- SERIALIZATION_FUNCS: Dict[str, Callable[[Any], str]] = {'iso': <function isoformat>, 'iso8601': <function isoformat>, 'rfc': <function rfcformat>, 'rfc822': <function rfcformat>}¶
- default_error_messages = {'format': '"{input}" cannot be formatted as a {obj_type}.', 'invalid': 'Not a valid {obj_type}.', 'invalid_awareness': 'Not a valid {awareness} {obj_type}.'}¶
Default error messages.
- class labthings.fields.Decimal(places: Optional[int] = None, rounding: Optional[str] = None, *, allow_nan: bool = False, as_string: bool = False, **kwargs)¶
A field that (de)serializes to the Python
decimal.Decimal
type. It’s safe to use when dealing with money values, percentages, ratios or other numbers where precision is critical.Warning
This field serializes to a decimal.Decimal object by default. If you need to render your data as JSON, keep in mind that the json module from the standard library does not encode decimal.Decimal. Therefore, you must use a JSON library that can handle decimals, such as simplejson, or serialize to a string by passing
as_string=True
.Warning
If a JSON float value is passed to this field for deserialization it will first be cast to its corresponding string value before being deserialized to a decimal.Decimal object. The default __str__ implementation of the built-in Python float type may apply a destructive transformation upon its input data and therefore cannot be relied upon to preserve precision. To avoid this, you can instead pass a JSON string to be deserialized directly.
- Parameters
places – How many decimal places to quantize the value. If None, does not quantize the value.
rounding – How to round the value during quantize, for example decimal.ROUND_UP. If None, uses the rounding value from the current thread’s context.
allow_nan – If True, NaN, Infinity and -Infinity are allowed, even though they are illegal according to the JSON specification.
as_string – If True, serialize to a string instead of a Python decimal.Decimal type.
kwargs – The same keyword arguments that
Number
receives.
New in version 1.2.0.
- default_error_messages = {'special': 'Special numeric values (nan or infinity) are not permitted.'}¶
Default error messages.
- num_type¶
alias of
decimal.Decimal
- class labthings.fields.Dict(keys: Optional[Union[marshmallow.fields.Field, type]] = None, values: Optional[Union[marshmallow.fields.Field, type]] = None, **kwargs)¶
A dict field. Supports dicts and dict-like objects. Extends Mapping with dict as the mapping_type.
Example:
numbers = fields.Dict(keys=fields.Str(), values=fields.Float())
- Parameters
kwargs – The same keyword arguments that
Mapping
receives.
New in version 2.1.0.
- mapping_type¶
alias of
dict
- class labthings.fields.Email(*args, **kwargs)¶
An email field.
- Parameters
- default_error_messages = {'invalid': 'Not a valid email address.'}¶
Default error messages.
- class labthings.fields.Field(*, load_default: Any = <marshmallow.missing>, missing: Any = <marshmallow.missing>, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, data_key: Optional[str] = None, attribute: Optional[str] = None, validate: Optional[Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]] = None, required: bool = False, allow_none: Optional[bool] = None, load_only: bool = False, dump_only: bool = False, error_messages: Optional[Dict[str, str]] = None, metadata: Optional[Mapping[str, Any]] = None, **additional_metadata)¶
Basic field from which other fields should extend. It applies no formatting by default, and should only be used in cases where data does not need to be formatted before being serialized or deserialized. On error, the name of the field will be returned.
- Parameters
dump_default – If set, this value will be used during serialization if the input value is missing. If not set, the field will be excluded from the serialized output if the input value is missing. May be a value or a callable.
load_default – Default deserialization value for the field if the field is not found in the input data. May be a value or a callable.
data_key – The name of the dict key in the external representation, i.e. the input of load and the output of dump. If None, the key will match the name of the field.
attribute – The name of the attribute to get the value from when serializing. If None, assumes the attribute has the same name as the field. Note: This should only be used for very specific use cases such as outputting multiple fields for a single attribute. In most cases, you should use
data_key
instead.validate – Validator or collection of validators that are called during deserialization. Validator takes a field’s input value as its only parameter and returns a boolean. If it returns False, an
ValidationError
is raised.required – Raise a
ValidationError
if the field value is not supplied during deserialization.allow_none – Set this to True if None should be considered a valid value during validation/deserialization. If
missing=None
andallow_none
is unset, will default toTrue
. Otherwise, the default isFalse
.load_only – If True skip this field during serialization, otherwise its value will be present in the serialized data.
dump_only – If True skip this field during deserialization, otherwise its value will be present in the deserialized object. In the context of an HTTP API, this effectively marks the field as “read-only”.
error_messages (dict) – Overrides for Field.default_error_messages.
metadata – Extra information to be stored as field metadata.
Changed in version 2.0.0: Removed error parameter. Use
error_messages
instead.Changed in version 2.0.0: Added allow_none parameter, which makes validation/deserialization of None consistent across fields.
Changed in version 2.0.0: Added load_only and dump_only parameters, which allow field skipping during the (de)serialization process.
Changed in version 2.0.0: Added missing parameter, which indicates the value for a field if the field is not found during deserialization.
Changed in version 2.0.0:
default
value is only used if explicitly set. Otherwise, missing values inputs are excluded from serialized output.Changed in version 3.0.0b8: Add
data_key
parameter for the specifying the key in the input and output data. This parameter replaced bothload_from
anddump_to
.- property context¶
The context dictionary for the parent
Schema
.
- property default¶
- default_error_messages = {'null': 'Field may not be null.', 'required': 'Missing data for required field.', 'validator_failed': 'Invalid value.'}¶
Default error messages for various kinds of errors. The keys in this dictionary are passed to Field.make_error. The values are error messages passed to
marshmallow.exceptions.ValidationError
.
- deserialize(value: Any, attr: Optional[str] = None, data: Optional[Mapping[str, Any]] = None, **kwargs)¶
Deserialize
value
.- Parameters
value – The value to deserialize.
attr – The attribute/key in data to deserialize.
data – The raw input data passed to Schema.load.
kwargs – Field-specific keyword arguments.
- Raises
ValidationError – If an invalid value is passed or if a required value is missing.
- fail(key: str, **kwargs)¶
Helper method that raises a ValidationError with an error message from
self.error_messages
.Deprecated since version 3.0.0: Use make_error <marshmallow.fields.Field.make_error> instead.
- get_value(obj, attr, accessor=None, default=<marshmallow.missing>)¶
Return the value for a given key from an object.
- Parameters
obj (object) – The object to get the value from.
attr (str) – The attribute/key in obj to get the value from.
accessor (callable) – A callable used to retrieve the value of attr from the object obj. Defaults to marshmallow.utils.get_value.
- make_error(key: str, **kwargs) marshmallow.exceptions.ValidationError ¶
Helper method to make a ValidationError with an error message from
self.error_messages
.
- property missing¶
- serialize(attr: str, obj: Any, accessor: Optional[Callable[[Any, str, Any], Any]] = None, **kwargs)¶
Pulls the value for the given key from the object, applies the field’s formatting and returns the result.
- Parameters
attr – The attribute/key to get from the object.
obj – The object to access the attribute/key from.
accessor – Function used to access values from
obj
.kwargs – Field-specific keyword arguments.
- class labthings.fields.Float(*, allow_nan: bool = False, as_string: bool = False, **kwargs)¶
A double as an IEEE-754 double precision string.
- Parameters
allow_nan (bool) – If True, NaN, Infinity and -Infinity are allowed, even though they are illegal according to the JSON specification.
as_string (bool) – If True, format the value as a string.
kwargs – The same keyword arguments that
Number
receives.
- default_error_messages = {'special': 'Special numeric values (nan or infinity) are not permitted.'}¶
Default error messages.
- num_type¶
alias of
float
- class labthings.fields.Function(serialize: Optional[Union[Callable[[Any], Any], Callable[[Any, Dict], Any]]] = None, deserialize: Optional[Union[Callable[[Any], Any], Callable[[Any, Dict], Any]]] = None, **kwargs)¶
A field that takes the value returned by a function.
- Parameters
serialize – A callable from which to retrieve the value. The function must take a single argument
obj
which is the object to be serialized. It can also optionally take acontext
argument, which is a dictionary of context variables passed to the serializer. If no callable is provided then the`load_only`
flag will be set to True.deserialize – A callable from which to retrieve the value. The function must take a single argument
value
which is the value to be deserialized. It can also optionally take acontext
argument, which is a dictionary of context variables passed to the deserializer. If no callable is provided then`value`
will be passed through unchanged.
Changed in version 2.3.0: Deprecated
func
parameter in favor ofserialize
.Changed in version 3.0.0a1: Removed
func
parameter.
- labthings.fields.Int¶
alias of
marshmallow.fields.Integer
- class labthings.fields.Integer(*, strict: bool = False, **kwargs)¶
An integer field.
- Parameters
strict – If True, only integer types are valid. Otherwise, any value castable to int is valid.
kwargs – The same keyword arguments that
Number
receives.
- default_error_messages = {'invalid': 'Not a valid integer.'}¶
Default error messages.
- num_type¶
alias of
int
- class labthings.fields.List(cls_or_instance: Union[marshmallow.fields.Field, type], **kwargs)¶
A list field, composed with another Field class or instance.
Example:
numbers = fields.List(fields.Float())
- Parameters
cls_or_instance – A field class or instance.
kwargs – The same keyword arguments that
Field
receives.
Changed in version 2.0.0: The
allow_none
parameter now applies to deserialization and has the same semantics as the other fields.Changed in version 3.0.0rc9: Does not serialize scalar values to single-item lists.
- default_error_messages = {'invalid': 'Not a valid list.'}¶
Default error messages.
- class labthings.fields.Mapping(keys: Optional[Union[marshmallow.fields.Field, type]] = None, values: Optional[Union[marshmallow.fields.Field, type]] = None, **kwargs)¶
An abstract class for objects with key-value pairs.
- Parameters
keys – A field class or instance for dict keys.
values – A field class or instance for dict values.
kwargs – The same keyword arguments that
Field
receives.
Note
When the structure of nested data is not known, you may omit the keys and values arguments to prevent content validation.
New in version 3.0.0rc4.
- default_error_messages = {'invalid': 'Not a valid mapping type.'}¶
Default error messages.
- mapping_type¶
alias of
dict
- class labthings.fields.Method(serialize: Optional[str] = None, deserialize: Optional[str] = None, **kwargs)¶
A field that takes the value returned by a Schema method.
- Parameters
serialize (str) – The name of the Schema method from which to retrieve the value. The method must take an argument
obj
(in addition to self) that is the object to be serialized.deserialize (str) – Optional name of the Schema method for deserializing a value The method must take a single argument
value
, which is the value to deserialize.
Changed in version 2.0.0: Removed optional
context
parameter on methods. Useself.context
instead.Changed in version 2.3.0: Deprecated
method_name
parameter in favor ofserialize
and allowserialize
to not be passed at all.Changed in version 3.0.0: Removed
method_name
parameter.
- class labthings.fields.NaiveDateTime(format: Optional[str] = None, *, timezone: Optional[datetime.timezone] = None, **kwargs)¶
A formatted naive datetime string.
- Parameters
New in version 3.0.0rc9.
- AWARENESS = 'naive'¶
- class labthings.fields.Nested(nested: Union[marshmallow.base.SchemaABC, type, str, Callable[[], marshmallow.base.SchemaABC]], *, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, only: Optional[Union[Sequence[str], Set[str]]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, unknown: Optional[str] = None, **kwargs)¶
Allows you to nest a
Schema
inside a field.Examples:
class ChildSchema(Schema): id = fields.Str() name = fields.Str() # Use lambda functions when you need two-way nesting or self-nesting parent = fields.Nested(lambda: ParentSchema(only=("id",)), dump_only=True) siblings = fields.List(fields.Nested(lambda: ChildSchema(only=("id", "name")))) class ParentSchema(Schema): id = fields.Str() children = fields.List( fields.Nested(ChildSchema(only=("id", "parent", "siblings"))) ) spouse = fields.Nested(lambda: ParentSchema(only=("id",)))
When passing a Schema <marshmallow.Schema> instance as the first argument, the instance’s
exclude
,only
, andmany
attributes will be respected.Therefore, when passing the
exclude
,only
, ormany
arguments to fields.Nested, you should pass a Schema <marshmallow.Schema> class (not an instance) as the first argument.# Yes author = fields.Nested(UserSchema, only=('id', 'name')) # No author = fields.Nested(UserSchema(), only=('id', 'name'))
- Parameters
nested – Schema instance, class, class name (string), or callable that returns a Schema instance.
exclude – A list or tuple of fields to exclude.
only – A list or tuple of fields to marshal. If None, all fields are marshalled. This parameter takes precedence over
exclude
.many – Whether the field is a collection of objects.
unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE.
kwargs – The same keyword arguments that
Field
receives.
- default_error_messages = {'type': 'Invalid type.'}¶
Default error messages.
- property schema¶
The nested Schema object.
Changed in version 1.0.0: Renamed from serializer to schema.
- class labthings.fields.Number(*, as_string: bool = False, **kwargs)¶
Base class for number fields.
- Parameters
as_string (bool) – If True, format the serialized value as a string.
kwargs – The same keyword arguments that
Field
receives.
- default_error_messages = {'invalid': 'Not a valid number.', 'too_large': 'Number too large.'}¶
Default error messages.
- num_type¶
alias of
float
- class labthings.fields.Pluck(nested: Union[marshmallow.base.SchemaABC, type, str, Callable[[], marshmallow.base.SchemaABC]], field_name: str, **kwargs)¶
Allows you to replace nested data with one of the data’s fields.
Example:
from marshmallow import Schema, fields class ArtistSchema(Schema): id = fields.Int() name = fields.Str() class AlbumSchema(Schema): artist = fields.Pluck(ArtistSchema, 'id') in_data = {'artist': 42} loaded = AlbumSchema().load(in_data) # => {'artist': {'id': 42}} dumped = AlbumSchema().dump(loaded) # => {'artist': 42}
- class labthings.fields.Raw(*, load_default: Any = <marshmallow.missing>, missing: Any = <marshmallow.missing>, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, data_key: Optional[str] = None, attribute: Optional[str] = None, validate: Optional[Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]] = None, required: bool = False, allow_none: Optional[bool] = None, load_only: bool = False, dump_only: bool = False, error_messages: Optional[Dict[str, str]] = None, metadata: Optional[Mapping[str, Any]] = None, **additional_metadata)¶
Field that applies no formatting.
- labthings.fields.Str¶
alias of
marshmallow.fields.String
- class labthings.fields.String(*, load_default: Any = <marshmallow.missing>, missing: Any = <marshmallow.missing>, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, data_key: Optional[str] = None, attribute: Optional[str] = None, validate: Optional[Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]] = None, required: bool = False, allow_none: Optional[bool] = None, load_only: bool = False, dump_only: bool = False, error_messages: Optional[Dict[str, str]] = None, metadata: Optional[Mapping[str, Any]] = None, **additional_metadata)¶
A string field.
- Parameters
kwargs – The same keyword arguments that
Field
receives.
- default_error_messages = {'invalid': 'Not a valid string.', 'invalid_utf8': 'Not a valid utf-8 string.'}¶
Default error messages.
- class labthings.fields.Time(format: Optional[str] = None, **kwargs)¶
A formatted time string.
Example:
'03:12:58.019077'
- Parameters
format – Either
"iso"
(for ISO8601) or a date format string. If None, defaults to “iso”.kwargs – The same keyword arguments that
Field
receives.
- DEFAULT_FORMAT = 'iso'¶
- DESERIALIZATION_FUNCS: Dict[str, Callable[[str], Any]] = {'iso': <function from_iso_time>, 'iso8601': <function from_iso_time>}¶
- OBJ_TYPE = 'time'¶
- SCHEMA_OPTS_VAR_NAME = 'timeformat'¶
- class labthings.fields.TimeDelta(precision: str = 'seconds', **kwargs)¶
A field that (de)serializes a
datetime.timedelta
object to an integer and vice versa. The integer can represent the number of days, seconds or microseconds.- Parameters
precision – Influences how the integer is interpreted during (de)serialization. Must be ‘days’, ‘seconds’, ‘microseconds’, ‘milliseconds’, ‘minutes’, ‘hours’ or ‘weeks’.
kwargs – The same keyword arguments that
Field
receives.
Changed in version 2.0.0: Always serializes to an integer value to avoid rounding errors. Add precision parameter.
- DAYS = 'days'¶
- HOURS = 'hours'¶
- MICROSECONDS = 'microseconds'¶
- MILLISECONDS = 'milliseconds'¶
- MINUTES = 'minutes'¶
- SECONDS = 'seconds'¶
- WEEKS = 'weeks'¶
- default_error_messages = {'format': '{input!r} cannot be formatted as a timedelta.', 'invalid': 'Not a valid period of time.'}¶
Default error messages.
- class labthings.fields.Tuple(tuple_fields, *args, **kwargs)¶
A tuple field, composed of a fixed number of other Field classes or instances
Example:
row = Tuple((fields.String(), fields.Integer(), fields.Float()))
Note
Because of the structured nature of collections.namedtuple and typing.NamedTuple, using a Schema within a Nested field for them is more appropriate than using a Tuple field.
- Parameters
New in version 3.0.0rc4.
- default_error_messages = {'invalid': 'Not a valid tuple.'}¶
Default error messages.
- labthings.fields.URL¶
alias of
marshmallow.fields.Url
- class labthings.fields.UUID(*, load_default: Any = <marshmallow.missing>, missing: Any = <marshmallow.missing>, dump_default: Any = <marshmallow.missing>, default: Any = <marshmallow.missing>, data_key: Optional[str] = None, attribute: Optional[str] = None, validate: Optional[Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]] = None, required: bool = False, allow_none: Optional[bool] = None, load_only: bool = False, dump_only: bool = False, error_messages: Optional[Dict[str, str]] = None, metadata: Optional[Mapping[str, Any]] = None, **additional_metadata)¶
A UUID field.
- default_error_messages = {'invalid_uuid': 'Not a valid UUID.'}¶
Default error messages.
- class labthings.fields.Url(*, relative: bool = False, schemes: Optional[Union[Sequence[str], Set[str]]] = None, require_tld: bool = True, **kwargs)¶
An URL field.
- Parameters
default – Default value for the field if the attribute is not set.
relative – Whether to allow relative URLs.
require_tld – Whether to reject non-FQDN hostnames.
schemes – Valid schemes. By default,
http
,https
,ftp
, andftps
are allowed.kwargs – The same keyword arguments that
String
receives.
- default_error_messages = {'invalid': 'Not a valid URL.'}¶
Default error messages.