How to make schema for dict fields with variable names?

For example, suppose we have the following JSON schema:

...
"metrics": {
  "type": "object",
  "patternProperties": {
    "^[a-zA-Z]+$": {
      "type": "object",
      "required": ["v", "date"],
      "properties": {
        "v": {"type": "number"},
        "date": {"type": "string"}
      },
      "additionalProperties": false
    }
  }
}
...

How to define marshmallow’s schema for it?

I can validate it like this:

@MetricsSchema.validator
def validate_metrics(schema, input_data):
    metric_key, metric_value = input_data['metrics'].items()[0]
    if not re.compile(r'^[a-zA-Z]+$').match(metric_key):
        raise ValidationError('Metric\'s name must be alphabetical symbols.')
    errors = PredefinedMetricSchema().validate(metric_value)
    if errors:
        raise ValidationError(errors)

But how to make schema for serializing? I think it should have clear decision, because this case can be occured in schemas in your new project named smore.

[sloria]

@vovanbo Apologies for the delayed response. Here’s a stab at a DictField that might meet your use case:

from marshmallow import Schema, fields, validate

class DictField(fields.Field):

    def __init__(self, key_field, nested_field, *args, **kwargs):
        fields.Field.__init__(self, *args, **kwargs)
        self.key_field = key_field
        self.nested_field = nested_field

    def _deserialize(self, value):
        ret = {}
        for key, val in value.items():
            k = self.key_field.deserialize(key)
            v = self.nested_field.deserialize(val)
            ret[k] = v
        return ret

    def _serialize(self, value, attr, obj):
        ret = {}
        for key, val in value.items():
            k = self.key_field._serialize(key, attr, obj)
            v = self.nested_field.serialize(key, self.get_value(attr, obj))
            ret[k] = v
        return ret


class MetricSchema(Schema):
    value = fields.Float()
    date = fields.DateTime()

class UserSchema(Schema):
    metrics = DictField(
        fields.Str(validate=validate.Regexp(r'^[a-zA-Z]+$')), 
        fields.Nested(MetricSchema)
    )

metrics = {
    "metrics": {
        "firstMetricName": {
            "value": 100,
            "date": "2015-01-09T04:33:17+00:00"
        },
        "secondMetricName": {
            "value": 110,
            "date": "2015-01-09T04:33:17+00:00"
        }
    }
}

s = UserSchema(strict=True)
s.load(metrics).data
# {'metrics': {'firstMetricName': {'value': 100.0,
#    'date': datetime.datetime(2015, 1, 9, 4, 33, 17, tzinfo=tzutc())},
#   'secondMetricName': {'value': 110.0,
#    'date': datetime.datetime(2015, 1, 9, 4, 33, 17, tzinfo=tzutc())}}}

[lauwers]

I noticed you added a regular Dict(), but are there any plans to support the DictField() as presented above? I have lots of maps of named objects for which this functionality would be useful.