All tests are functional

pydantic_form/iterators.py

@@ -67,22 +67,6 @@ def iter_schema_class(schema, leafs_only=True, path=()):
     for key, field in schema.__fields__.items():
         yield from iter_schema_class_field(field, leafs_only, path + (key,))
 
-def get_schema_value(schema, key):
-    parent = None
-    idx = None
-    if is_int(key[-1]):
-        *parent, idx = key
-    try:
-        if parent:
-            return rgetattr(getattr(schema, parent[0])[idx], tuple(parent[1:]))
-        else:
-            return rgetattr(schema, key)
-    except AttributeError:
-        if parent:
-            return recursive_get(getattr(schema, parent[0])[idx], *parent[1:])
-        else:
-            return recursive_get(schema, *key)
-
 
 def iter_schema(schema, leafs_only=True):
     def get_schema_value(schema, key):
@@ -103,13 +87,14 @@ def iter_schema(schema, leafs_only=True):
                         yield iterate_on + (n, *key[len(iterate_on):]), get_schema_value(sub_value, key[len(iterate_on):])
                 else:
                     raise NotImplementedError()
-            except AttributeError:
-                print('attr error')
-                ...
+            except AttributeError as e:
+                if schema.dict() != {}:
+                    raise e
 
             continue
 
         try:
             yield key, get_schema_value(schema, key)
-        except AttributeError:
-            ...
+        except AttributeError as e:
+            if schema.dict() != {}:
+                raise e

pydantic_form/translator.py

@@ -1,5 +1,5 @@
 from wtforms import FieldList, FormField
-from .iterators import iter_schema, iter_form, get_schema_value
+from .iterators import iter_schema, iter_form
 from .utils import *
 from pydantic import ValidationError
 
@@ -39,6 +39,17 @@ class SchemaToForm:
     def errors(self):
         return self._errors
 
+    @classmethod
+    def get_item(cls, dict, key):
+        for k in key:
+            if is_int(k):
+                sub_dict = dict[k]
+            else:
+                sub_dict = dict[k]
+            return cls.get_item(sub_dict, key[1:])
+
+        return dict
+
     @classmethod
     def get_field(cls, form, key):
         for k in key:
@@ -82,16 +93,15 @@ class SchemaToForm:
                 setattr(dest_field, 'data', value)
 
     def set_baked(self):
-        for k, field in iter_form(self.form):
-            field._baked_instance = self.get_schema(self.schema, k)
+        for k, field in iter_form(self.form, leafs_only=False):
+            field = self.get_field(self.form, k)
+            if isinstance(field, FormField):
+                field._baked_instance = self.get_schema(self.schema, k)
 
     def set_errors(self):
         for k, error_list in nested_dict_iter(self.errors):
-
             try:
-                print(k)
                 field = self.get_field(self.form, k)
-                print(k, field.__class__)
                 if isinstance(field, FormField):
                     setattr(field.form, '_errors', error_list)
                 else:

pydantic_form/utils.py

@@ -55,12 +55,18 @@ def default_to_regular(d):
     return d
 
 
-def nested_dict_iter(nested, path=()):
-    for key, value in nested.items():
-        if isinstance(value, abc.Mapping):
-            yield from nested_dict_iter(value, path + (key,))
-        else:
-            yield path + (key,), value
+def nested_dict_iter(nested, path=(), iter_list=False):
+    try:
+        for key, value in nested.items():
+            if isinstance(value, abc.Mapping):
+                yield from nested_dict_iter(value, path + (key,))
+            elif iter_list and isinstance(value, abc.Iterable) and not isinstance(value, str):
+                for n, sub_val in enumerate(value):
+                    yield from nested_dict_iter(sub_val, path + (key, n))
+            else:
+                yield path + (key,), value
+    except AttributeError:
+        yield path, nested
 
 
 def to_formdata_item(data, prefix=''):

tests/conftest.py

@@ -86,12 +86,12 @@ simple_data_factories = DataFactories(
 simple_expected_errors = ExpectedErrors(
     {},
     {
-        ('integer',): 'type_error.integer',
-        ('string',): 'type_error.str'
+        'integer': 'type_error.integer',
+        'string': 'type_error.str'
     },
     {
-        ('integer',): 'value_error.missing',
-        ('string',): 'value_error.missing',
+        'integer': 'value_error.missing',
+        'string': 'value_error.missing',
     }
 )
 
@@ -150,12 +150,12 @@ simple_list_data_factories = DataFactories(
 simple_list_expected_errors = ExpectedErrors(
     {},
     {
-        ('integers',): ['type_error.integer', 'type_error.integer'],
-        ('strings',): ['type_error.str', 'type_error.str']
+        'integers': ['type_error.integer', 'type_error.integer'],
+        'strings': ['type_error.str', 'type_error.str']
     },
     {
-        ('integers',): 'value_error.missing',
-        ('strings',): 'value_error.missing'
+        'integers': 'value_error.missing',
+        'strings': 'value_error.missing'
     }
 )
 
@@ -217,13 +217,15 @@ nested_data_factories = DataFactories(
 nested_expected_errors = ExpectedErrors(
     {},
     {
-        ('integer',): 'type_error.integer',
-        ('nested', 'integer',): 'type_error.integer',
-        ('nested', 'string',): 'type_error.str'
+        'integer': 'type_error.integer',
+        'nested': {
+            'integer': 'type_error.integer',
+            'string': 'type_error.str'
+        }
     },
     {
-        ('integer',): 'value_error.missing',
-        ('nested',): 'value_error.missing',
+        'integer': 'value_error.missing',
+        'nested': 'value_error.missing',
     }
 )
 
@@ -297,13 +299,15 @@ nested_list_data_factories = DataFactories(
 nested_list_expected_errors = ExpectedErrors(
     {},
     {
-        ('integer',): 'type_error.integer',
-        ('nested_list', 'integer',): ['type_error.integer', 'type_error.integer'],
-        ('nested_list', 'string',): ['type_error.str', 'type_error.str']
+        'integer': 'type_error.integer',
+        'nested_list': [
+            {'integer': 'type_error.integer'},
+            {'string': 'type_error.str'}
+        ],
     },
     {
-        ('integer',): 'value_error.missing',
-        ('nested_list',): 'value_error.missing',
+        'integer': 'value_error.missing',
+        'nested_list': 'value_error.missing',
     }
 )
 
@@ -373,14 +377,18 @@ double_nested_data_factories = DataFactories(
 double_nested_expected_errors = ExpectedErrors(
     {},
     {
-        ('integer',): 'type_error.integer',
-        ('double_nested', 'integer',): 'type_error.integer',
-        ('double_nested', 'nested', 'integer',): 'type_error.integer',
-        ('double_nested', 'nested', 'string',): 'type_error.str'
+        'integer': 'type_error.integer',
+        'double_nested': {
+            'integer': 'type_error.integer',
+            'nested': {
+                'integer': 'type_error.integer',
+                'string': 'type_error.str'
+            }
+        }
     },
     {
-        ('integer',): 'value_error.missing',
-        ('double_nested',): 'value_error.missing',
+        'integer': 'value_error.missing',
+        'double_nested': 'value_error.missing',
     }
 )
 

tests/test_process.py

@@ -1,8 +1,8 @@
 import pytest
 from wtforms import FormField
 
-from pydantic_form.translator import iter_form
-from pydantic_form.utils import recursive_get, formdata_mangle
+from pydantic_form.translator import iter_form, SchemaToForm
+from pydantic_form.utils import recursive_get, formdata_mangle, nested_dict_iter
 
 
 @pytest.fixture
@@ -97,7 +97,6 @@ def test_errors_valid(scenario, data):
     form = scenario.form(data=data)
     assert form.errors == {}
 
-import pprint
 @pytest.mark.parametrize(
     'data, errors_factory',
     [
@@ -116,12 +115,8 @@ def test_errors_invalid(scenario, data, errors_factory):
 
     form.validate()
     assert form.errors
-    print()
-    pprint.pprint(form.translator.errors)
-    pprint.pprint(form.errors)
-    for k, expected in errors_factory(scenario).items():
-        print(k, expected)
-        field_errors = recursive_get(form.errors, *k)
+    for k, expected in nested_dict_iter(errors_factory(scenario), iter_list=True):
+        field_errors = SchemaToForm.get_item(form.errors, k)
         if isinstance(expected, list):
             errors = [e['type'] for e_list in field_errors for e in e_list]
             assert errors == expected
@@ -130,7 +125,7 @@ def test_errors_invalid(scenario, data, errors_factory):
             errors = [e['type'] for e in field_errors]
             assert len(errors) == 1
             assert errors[0] == expected
-from pydantic_form.translator import SchemaToForm
+
 
 @pytest.mark.parametrize(
     'data',
@@ -152,12 +147,8 @@ def test_baked_instance(scenario, data):
     assert form._baked_instance.dict() == data
 
     for key, sub_form in iter_form(form, leafs_only=False):
-
-        print(key, sub_form)
         sub_form = SchemaToForm.get_field(form, key)
-        print(key, sub_form)
         if isinstance(sub_form, FormField):
-            print('?')
             assert hasattr(sub_form, '_baked_instance')
             assert sub_form._baked_instance is not None
-            assert sub_form._baked_instance.dict() == recursive_get(data, *key)
+            assert sub_form._baked_instance.dict() == SchemaToForm.get_item(data, key)