for validator in self.chained_validators:
                if (not hasattr(validator, 'validate_partial') or not getattr(
                        validator, 'validate_partial_form', False)):
                    continue
                try:
                    validator.validate_partial(value_dict, state)
                except Invalid as e:
                    sub_errors = e.unpack_errors()
                    if not isinstance(sub_errors, dict):
                        # Can't do anything here
                        continue
                    merge_dicts(errors, sub_errors)

from formencode import (
    Invalid,
    validators,
)
from formencode.schema import Schema


class Name(Schema):
    fname = validators.String(not_empty=True)
    mi = validators.String(max=1, if_missing=None, if_empty=None)
    lname = validators.String(not_empty=True)


class ChainedTest(Schema):
    a = validators.String()
    a_confirm = validators.String()

    b = validators.String()
    b_confirm = validators.String()

    chained_validators = [validators.FieldsMatch('a', 'a_confirm'),
                            validators.FieldsMatch('b', 'b_confirm')]


class NestedSchemaValidator(Schema):

    name = Name(if_missing=None)
    chained_test = ChainedTest(if_missing=None)


class PartialFormValidator(validators.FormValidator):
    """
    Call the NestedSchemaValidator validator as a post/chained validator to a form
    """
    validate_partial_form = True

    def validate_partial(self, field_dict, state):
        self._validate_python(field_dict, state)

    def _validate_python(self, field_dict, state):
        NestedSchemaValidator().to_python(field_dict, state)


class PartialFormSchemaValidator(Schema):

    allow_extra_fields = True
    chained_validators = [
        PartialFormValidator(),
    ]

def test_partial_form_with_nested_forms_validators():

    def invalid_eq(self, other):
        if not isinstance(other, type(self)):
            return False

        # state is more debug than identity information
        return (
            self.msg == other.msg
            and self.error_dict == other.error_dict
            and self.error_list == other.error_list
        )

    Invalid.__eq__ = invalid_eq

    nested_validator = NestedSchemaValidator()
    partial_validator = PartialFormSchemaValidator()

    try:
        partial_validator.to_python(
            {'chained_test': {'a': '1', 'a_confirm': '2', 'b': '3', 'b_confirm': '4'}}
        )
    except Invalid as e:
        partial_error = e

    else:
        assert False

    try:
        nested_validator.to_python(
            {'chained_test': {'a': '1', 'a_confirm': '2', 'b': '3', 'b_confirm': '4'}}
        )
    except Invalid as e:
        expected_error = e

    else:
        assert False

    assert expected_error.error_dict == partial_error.error_dict

    try:
        partial_validator.to_python(
            {'chained_test': {}}
        )
    except Invalid as e:
        partial_error = e

    else:
        assert False

    try:
        nested_validator.to_python(
            {'chained_test': {}}
        )
    except Invalid as e:
        expected_error = e

    else:
        assert False

    assert expected_error.error_dict == partial_error.error_dict