Support tuples in forms (#52)

Co-authored-by: Samuel Colvin <s@muelcolvin.com>

Author: WolfDWyc

demo/forms.py

@@ -155,6 +155,11 @@ class BigModel(BaseModel):
     )
     size: SizeModel
 
+    position: tuple[
+        Annotated[int, Field(description='X Coordinate')],
+        Annotated[int, Field(description='Y Coordinate')],
+    ]
+
     @field_validator('name')
     def name_validator(cls, v: str | None) -> str:
         if v and v[0].islower():

src/python-fastui/fastui/forms.py

@@ -199,6 +199,19 @@ def unflatten(form_data: ds.FormData) -> NestedDict:
         else:
             d[last_key] = values
 
+    # this logic takes care of converting `dict[int, str]` to `list[str]`
+    # we recursively process each dict in `result_dict` and convert it to a list if all keys are ints
+    dicts = [result_dict]
+    while dicts:
+        d = dicts.pop()
+        for key, value in d.items():
+            if isinstance(value, dict):
+                if all(isinstance(k, int) for k in value):
+                    # sort key-value pairs based on the keys, then take just the values as a list
+                    d[key] = [v for _, v in sorted(value.items())]
+                else:
+                    dicts.append(value)
+
     return result_dict
 
 

src/python-fastui/fastui/json_schema.py

@@ -203,8 +203,24 @@ def json_schema_array_to_fields(
             if value := schema.get(field_name):
                 items_schema[field_name] = value  # type: ignore
         if field := special_string_field(items_schema, loc_to_name(loc), title, required, True):
-            return [field]
-    raise NotImplementedError('todo')
+            yield field
+            return
+
+    # for fixed length tuples (min_items == max_items), where all items are required,
+    # we "inline" the fields into the list of form fields
+    if (min_items := schema.get('minItems')) and min_items == schema.get('maxItems'):
+        if items := schema.get('prefixItems'):
+            for i, item in enumerate(items):
+                fields = list(json_schema_any_to_fields(item, loc + [i], title, required, defs))
+                if any(not f.required for f in fields):
+                    raise NotImplementedError(
+                        'Tuples with optional fields are not yet supported, '
+                        'see https://github.com/pydantic/FastUI/pull/52'
+                    )
+                yield from fields
+            return
+
+    raise NotImplementedError('Array fields are not fully supported, see https://github.com/pydantic/FastUI/pull/52')
 
 
 def special_string_field(

src/python-fastui/tests/test_forms.py

@@ -334,3 +334,115 @@ async def test_multiple_files_multiple():
 
     m = await fastui_form(FormMultipleFiles).dependency(request)
     assert m.model_dump() == {'files': [file1, file2]}
+
+
+class FixedTuple(BaseModel):
+    foo: Tuple[str, int, int]
+
+
+def test_fixed_tuple():
+    m = components.ModelForm(model=FixedTuple, submit_url='/foo/')
+    # insert_assert(m.model_dump(by_alias=True, exclude_none=True))
+    assert m.model_dump(by_alias=True, exclude_none=True) == {
+        'submitUrl': '/foo/',
+        'method': 'POST',
+        'type': 'ModelForm',
+        'formFields': [
+            {
+                'name': 'foo.0',
+                'title': ['Foo', '0'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'text',
+                'type': 'FormFieldInput',
+            },
+            {
+                'name': 'foo.1',
+                'title': ['Foo', '1'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'number',
+                'type': 'FormFieldInput',
+            },
+            {
+                'name': 'foo.2',
+                'title': ['Foo', '2'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'number',
+                'type': 'FormFieldInput',
+            },
+        ],
+    }
+
+
+async def test_fixed_tuple_submit():
+    request = FakeRequest([('foo.0', 'bar'), ('foo.1', '123'), ('foo.2', '456')])
+
+    m = await fastui_form(FixedTuple).dependency(request)
+    assert m.model_dump() == {'foo': ('bar', 123, 456)}
+
+
+class NestedTuple(BaseModel):
+    bar: FixedTuple
+
+
+def test_fixed_tuple_nested():
+    m = components.ModelForm(model=NestedTuple, submit_url='/foobar/')
+    # insert_assert(m.model_dump(by_alias=True, exclude_none=True))
+    assert m.model_dump(by_alias=True, exclude_none=True) == {
+        'submitUrl': '/foobar/',
+        'method': 'POST',
+        'type': 'ModelForm',
+        'formFields': [
+            {
+                'name': 'bar.foo.0',
+                'title': ['FixedTuple', 'Foo', '0'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'text',
+                'type': 'FormFieldInput',
+            },
+            {
+                'name': 'bar.foo.1',
+                'title': ['FixedTuple', 'Foo', '1'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'number',
+                'type': 'FormFieldInput',
+            },
+            {
+                'name': 'bar.foo.2',
+                'title': ['FixedTuple', 'Foo', '2'],
+                'required': True,
+                'locked': False,
+                'htmlType': 'number',
+                'type': 'FormFieldInput',
+            },
+        ],
+    }
+
+
+async def test_fixed_tuple_nested_submit():
+    request = FakeRequest([('bar.foo.0', 'bar'), ('bar.foo.1', '123'), ('bar.foo.2', '456')])
+
+    m = await fastui_form(NestedTuple).dependency(request)
+    assert m.model_dump() == {'bar': {'foo': ('bar', 123, 456)}}
+
+
+def test_variable_tuple():
+    class VarTuple(BaseModel):
+        foo: Tuple[str, ...]
+
+    m = components.ModelForm(model=VarTuple, submit_url='/foo/')
+    with pytest.raises(NotImplementedError, match='Array fields are not fully supported'):
+        m.model_dump(by_alias=True, exclude_none=True)
+
+
+def test_tuple_optional():
+    class TupleOptional(BaseModel):
+        foo: Tuple[str, Union[str, None]]
+
+    m = components.ModelForm(model=TupleOptional, submit_url='/foo/')
+    with pytest.raises(NotImplementedError, match='Tuples with optional fields are not yet supported'):
+        m.model_dump(by_alias=True, exclude_none=True)