Fixed datalist example

Added other TestableControls

README.md

@@ -14,8 +14,9 @@ A utility library designed to simplify the development of FastHtml applications
 - **Dynamic HTML with HTMX**: Simplify dynamic interaction using attributes like `hx-post` and custom routes like
   `/commands`.
 - **Command management**: Write server-side logic in Python while abstracting the complexities of HTMX.
+- **Binding management**: Mechanism to bind two html element together.
 - **Control helpers**: Easily create reusable components like buttons.
-- **Predefined Pages (Roadmap)**: Include common pages like login, user management, and customizable dashboards.
+- **Login Pages**: Include common pages for login, user management, and customizable dashboards.
 
 > _**Note:** Support for state persistence is currently under construction._
 
@@ -57,7 +58,7 @@ if __name__ == "__main__":
 
 ```
 
-### Button with a Command
+### Use Commands
 
 ```python
 from fasthtml import serve
@@ -93,6 +94,23 @@ if __name__ == "__main__":
 
 ---
 
+### Bind components
+
+```python
+@dataclass
+class Data:
+  value: str = "Hello World"
+  checked: bool = False
+
+# Binds an Input with a label
+mk.mk(Input(name="input_name"), binding=Binding(data, attr="value").htmx(trigger="input changed")),
+mk.mk(Label("Text"), binding=Binding(data, attr="value")),
+
+# Binds a checkbox with a labl
+mk.mk(Input(name="checked_name", type="checkbox"), binding=Binding(data, attr="checked")),
+mk.mk(Label("Text"), binding=Binding(data, attr="checked")),
+```
+
 ## Planned Features (Roadmap)
 
 ### Predefined Pages
@@ -148,6 +166,655 @@ Use the `get_htmx_params()` method to directly integrate commands into HTML comp
 
 ---
 
+## Testing
+
+### TestableElements
+
+#### TestableTextarea
+
+**Use case:** Multi-line text input
+
+**Methods:**
+
+- `send(value)` - Set the textarea value
+- `append(text)` - Append text to current value
+- `clear()` - Clear the textarea
+
+**Example:**
+
+```python
+def test_textarea_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("Initial text")
+    textarea = Textarea(name="message")
+    label = Label()
+    
+    mk.manage_binding(textarea, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return textarea, label
+  
+  user.open("/")
+  textarea = user.find_element("textarea")
+  
+  textarea.send("New message")
+  user.should_see("New message")
+  
+  textarea.append("\nMore text")
+  user.should_see("New message\nMore text")
+  
+  textarea.clear()
+  user.should_see("")
+```
+
+#### TestableSelect
+
+**Use case:** Dropdown selection
+
+**Properties:**
+
+- `is_multiple` - Check if multiple selection is enabled
+- `options` - List of available options
+
+**Methods:**
+
+- `select(value)` - Select option by value
+- `select_by_text(text)` - Select option by visible text
+- `deselect(value)` - Deselect option (multiple select only)
+
+**Example (Single Select):**
+
+```python
+def test_select_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("option1")
+    select = Select(
+      Option("First", value="option1"),
+      Option("Second", value="option2"),
+      Option("Third", value="option3"),
+      name="choice"
+    )
+    label = Label()
+    
+    mk.manage_binding(select, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return select, label
+  
+  user.open("/")
+  select_elt = user.find_element("select")
+  
+  select_elt.select("option2")
+  user.should_see("option2")
+  
+  select_elt.select_by_text("Third")
+  user.should_see("option3")
+```
+
+**Example (Multiple Select):**
+
+```python
+def test_multiple_select_binding(user, rt):
+  @rt("/")
+  def index():
+    data = ListData(["option1"])
+    select = Select(
+      Option("First", value="option1"),
+      Option("Second", value="option2"),
+      Option("Third", value="option3"),
+      name="choices",
+      multiple=True
+    )
+    label = Label()
+    
+    mk.manage_binding(select, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return select, label
+  
+  user.open("/")
+  select_elt = user.find_element("select")
+  
+  select_elt.select("option2")
+  user.should_see("['option1', 'option2']")
+  
+  select_elt.deselect("option1")
+  user.should_see("['option2']")
+```
+
+#### TestableRange
+
+**Use case:** Slider input
+
+**Properties:**
+
+- `min_value` - Minimum value
+- `max_value` - Maximum value
+- `step` - Step increment
+
+**Methods:**
+
+- `set(value)` - Set slider to specific value (auto-clamped)
+- `increase()` - Increase by one step
+- `decrease()` - Decrease by one step
+
+**Example:**
+
+```python
+def test_range_binding(user, rt):
+  @rt("/")
+  def index():
+    data = NumericData(50)
+    range_input = Input(
+      type="range",
+      name="volume",
+      min="0",
+      max="100",
+      step="10",
+      value="50"
+    )
+    label = Label()
+    
+    mk.manage_binding(range_input, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return range_input, label
+  
+  user.open("/")
+  slider = user.find_element("input[type='range']")
+  
+  slider.set(75)
+  user.should_see("75")
+  
+  slider.increase()
+  user.should_see("85")
+  
+  slider.decrease()
+  user.should_see("75")
+```
+
+#### TestableRadio
+
+**Use case:** Radio button (mutually exclusive options)
+
+**Properties:**
+
+- `radio_value` - The value attribute of this radio
+- `is_checked` - Check if this radio is selected
+
+**Methods:**
+
+- `select()` - Select this radio button
+
+**Example:**
+
+```python
+def test_radio_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("option1")
+    
+    radio1 = Input(type="radio", name="choice", value="option1", checked=True)
+    radio2 = Input(type="radio", name="choice", value="option2")
+    radio3 = Input(type="radio", name="choice", value="option3")
+    label = Label()
+    
+    mk.manage_binding(radio1, Binding(data))
+    mk.manage_binding(radio2, Binding(data))
+    mk.manage_binding(radio3, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return radio1, radio2, radio3, label
+  
+  user.open("/")
+  
+  radio2 = user.find_element("input[value='option2']")
+  radio2.select()
+  user.should_see("option2")
+  
+  radio3 = user.find_element("input[value='option3']")
+  radio3.select()
+  user.should_see("option3")
+```
+
+#### TestableButton
+
+**Use case:** Clickable button with HTMX
+
+**Properties:**
+
+- `text` - Visible text of the button
+
+**Methods:**
+
+- `click()` - Click the button (triggers HTMX if configured)
+
+**Example:**
+
+```python
+def test_button_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("initial")
+    button = Button(
+      "Click me",
+      hx_post="/update",
+      hx_vals='{"action": "clicked"}'
+    )
+    label = Label()
+    
+    mk.manage_binding(button, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return button, label
+  
+  @rt("/update")
+  def update(action: str):
+    data = Data("updated")
+    label = Label()
+    mk.manage_binding(label, Binding(data))
+    return label
+  
+  user.open("/")
+  
+  button = user.find_element("button")
+  button.click()
+  user.should_see("updated")
+```
+
+#### TestableDatalist
+
+**Use case:** Input with autocomplete suggestions (combobox)
+
+**Properties:**
+
+- `suggestions` - List of available suggestions
+
+**Methods:**
+
+- `send(value)` - Set input value (any value, not restricted to suggestions)
+- `select_suggestion(value)` - Select a value from suggestions
+
+**Example:**
+
+```python
+def test_datalist_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("")
+    
+    datalist = Datalist(
+      Option(value="apple"),
+      Option(value="banana"),
+      Option(value="cherry"),
+      id="fruits"
+    )
+    input_elt = Input(name="fruit", list="fruits")
+    label = Label()
+    
+    mk.manage_binding(input_elt, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return input_elt, datalist, label
+  
+  user.open("/")
+  
+  input_with_list = user.find_element("input[list='fruits']")
+  
+  # Free text input
+  input_with_list.send("mango")
+  user.should_see("mango")
+  
+  # Select from suggestions
+  input_with_list.select_suggestion("banana")
+  user.should_see("banana")
+```
+
+## CSS Selectors for Finding Elements
+
+When using `user.find_element()`, use these selectors:
+
+| Component      | Selector Example                                       |
+|----------------|--------------------------------------------------------|
+| Input (text)   | `"input[name='field_name']"` or `"input[type='text']"` |
+| Checkbox       | `"input[type='checkbox']"`                             |
+| Radio          | `"input[type='radio']"` or `"input[value='option1']"`  |
+| Range          | `"input[type='range']"`                                |
+| Textarea       | `"textarea"` or `"textarea[name='field_name']"`        |
+| Select         | `"select"` or `"select[name='field_name']"`            |
+| Button         | `"button"` or `"button.primary"`                       |
+| Datalist Input | `"input[list='datalist_id']"`                          |
+
+## Binding
+
+### Overview
+
+This package contains everything needed to implement a complete binding system for FastHTML components.
+
+### Fully Supported Components Summary
+
+| Component         | Testable Class   | Binding Support |
+|-------------------|------------------|-----------------|
+| Input (text)      | TestableInput    | ✅               |
+| Checkbox          | TestableCheckbox | ✅               |
+| Textarea          | TestableTextarea | ✅               |
+| Select (single)   | TestableSelect   | ✅               |
+| Select (multiple) | TestableSelect   | ✅               |
+| Range (slider)    | TestableRange    | ✅               |
+| Radio buttons     | TestableRadio    | ✅               |
+| Button            | TestableButton   | ✅               |
+| Input + Datalist  | TestableDatalist | ✅               |
+
+### Supported Components
+
+#### 1. Input (Text)
+
+```python
+# Methods
+input.send(value)
+
+# Binding modes
+- ValueChange(default)
+- Text
+updates
+trigger
+data
+changes
+```
+
+#### 2. Checkbox
+
+```python
+# Methods
+checkbox.check()
+checkbox.uncheck()
+checkbox.toggle()
+
+# Binding modes
+- AttributePresence
+- Boolean
+data
+binding
+```
+
+#### 3. Textarea
+
+```python
+# Methods
+textarea.send(value)
+textarea.append(text)
+textarea.clear()
+
+# Binding modes
+- ValueChange
+- Multi - line
+text
+support
+```
+
+#### 4. Select (Single)
+
+```python
+# Methods
+select.select(value)
+select.select_by_text(text)
+
+# Properties
+select.options  # List of available options
+select.is_multiple  # False for single select
+
+# Binding modes
+- ValueChange
+- String
+value
+binding
+```
+
+#### 5. Select (Multiple)
+
+```python
+# Methods
+select.select(value)
+select.deselect(value)
+select.select_by_text(text)
+
+# Properties
+select.options
+select.is_multiple  # True for multiple select
+
+# Binding modes
+- ValueChange
+- List
+data
+binding
+```
+
+#### 6. Range (Slider)
+
+```python
+# Methods
+range.set(value)  # Auto-clamps to min/max
+range.increase()
+range.decrease()
+
+# Properties
+range.min_value
+range.max_value
+range.step
+
+# Binding modes
+- ValueChange
+- Numeric
+data
+binding
+```
+
+#### 7. Radio Buttons
+
+```python
+# Methods
+radio.select()
+
+# Properties
+radio.radio_value  # Value attribute
+radio.is_checked
+
+# Binding modes
+- ValueChange
+- String
+value
+binding
+- Mutually
+exclusive
+group
+behavior
+```
+
+#### 8. Button
+
+```python
+# Methods
+button.click()
+
+# Properties
+button.text  # Visible button text
+
+# Binding modes
+- Triggers
+HTMX
+requests
+- Can
+update
+bindings
+via
+server
+response
+```
+
+#### 9. Input + Datalist (Combobox)
+
+```python
+# Methods
+datalist.send(value)  # Any value
+datalist.select_suggestion(value)  # From suggestions
+
+# Properties
+datalist.suggestions  # Available options
+
+# Binding modes
+- ValueChange
+- Hybrid: free
+text + suggestions
+```
+
+### Architecture Overview
+
+#### Three-Phase Binding Lifecycle
+
+```python
+# Phase 1: Create (inactive)
+binding = Binding(data, "value")
+
+# Phase 2: Configure + Activate
+binding.bind_ft(element, name="input", attr="value")
+
+# Phase 3: Deactivate (cleanup)
+binding.deactivate()
+```
+
+#### Data Flow
+
+```
+User Input → HTMX Component → HTMX Request → Binding.update()
+                                                       ↓
+                                             setattr(data, attr, value)
+                                                       ↓
+                                                Observable triggers
+                                                       ↓
+                                                Binding.notify()
+                                                       ↓
+                                              Update all bound UI elements
+```
+
+### Quick Reference
+
+#### Creating a Binding
+
+```python
+# Simple binding
+binding = Binding(data, "value").bind_ft(
+  Input(name="input"),
+  name="input",
+  attr="value"
+)
+
+# With detection and update modes
+binding = Binding(data, "checked").bind_ft(
+  Input(type="checkbox", name="check"),
+  name="check",
+  attr="checked",
+  detection_mode=DetectionMode.AttributePresence,
+  update_mode=UpdateMode.AttributePresence
+)
+
+# With data converter
+binding = Binding(data, "value").bind_ft(
+  Input(type="checkbox", name="check"),
+  name="check",
+  attr="checked",
+  data_converter=BooleanConverter()
+)
+```
+
+#### Testing a Component
+
+```python
+def test_component_binding(user, rt):
+  @rt("/")
+  def index():
+    data = Data("initial")
+    component = Component(name="field")
+    label = Label()
+    
+    mk.manage_binding(component, Binding(data))
+    mk.manage_binding(label, Binding(data))
+    
+    return component, label
+  
+  user.open("/")
+  user.should_see("initial")
+  
+  testable = user.find_element("selector")
+  testable.method("new value")
+  user.should_see("new value")
+```
+
+#### Managing Binding Lifecycle
+
+```python
+# Create
+binding = Binding(data, "value")
+
+# Activate (via bind_ft)
+binding.bind_ft(element, name="field")
+
+# Deactivate
+binding.deactivate()
+
+# Reactivate with new element
+binding.bind_ft(new_element, name="field")
+```
+
+### Pattern 1: Bidirectional Binding
+
+All components support bidirectional binding:
+
+- UI changes update the data object
+- Data object changes update the UI (via Label or other bound components)
+
+```python
+input_elt = Input(name="field")
+label_elt = Label()
+
+mk.manage_binding(input_elt, Binding(data))
+mk.manage_binding(label_elt, Binding(data))
+
+# Change via UI
+testable_input.send("new value")
+# Label automatically updates to show "new value"
+```
+
+### Pattern 2: Multiple Components, Same Data
+
+Multiple different components can bind to the same data:
+
+```python
+input_elt = Input(name="input")
+textarea_elt = Textarea(name="textarea")
+label_elt = Label()
+
+# All bind to the same data object
+mk.manage_binding(input_elt, Binding(data))
+mk.manage_binding(textarea_elt, Binding(data))
+mk.manage_binding(label_elt, Binding(data))
+
+# Changing any component updates all others
+```
+
+### Pattern 3: Component Without Name
+
+Components without a name attribute won't trigger updates but won't crash:
+
+```python
+input_elt = Input()  # No name attribute
+label_elt = Label()
+
+mk.manage_binding(label_elt, Binding(data))
+# Input won't trigger updates, but label will still display data
+```
+
 ## Contributing
 
 We welcome contributions! To get started:
@@ -226,6 +893,41 @@ Predefined login page that provides a UI template ready for integration.
 
 No custom exceptions defined yet. (Placeholder for future use.)
 
+## Troubleshooting
+
+### Issue: "No element found matching selector"
+
+**Cause:** Incorrect CSS selector or element not in DOM
+
+**Solution:** Check the HTML output and adjust selector
+
+```python
+# Debug: Print the HTML
+print(user.get_content())
+
+# Try different selectors
+user.find_element("textarea")
+user.find_element("textarea[name='message']")
+```
+
+### Issue: TestableControl has no attribute 'send'
+
+**Cause:** Wrong testable class returned by factory
+
+**Solution:** Verify factory method is updated correctly
+
+### Issue: AttributeError on TestableTextarea
+
+**Cause:** Class not properly inheriting from TestableControl
+
+**Solution:** Check class hierarchy and imports
+
+### Issue: Select options not found
+
+**Cause:** `_update_fields()` not parsing select correctly
+
+**Solution:** Verify TestableElement properly parses select/option tags
+
 ## Relase History
 
 * 0.1.0 : First release

requirements.txt

@@ -36,7 +36,7 @@ markdown-it-py==4.0.0
 mdurl==0.1.2
 more-itertools==10.8.0
 myauth==0.2.0
-myutils==0.1.0
+myutils==0.4.0
 nh3==0.3.1
 oauthlib==3.3.1
 packaging==25.0

src/myfasthtml/controls/helpers.py

@@ -2,7 +2,7 @@ from fasthtml.components import *
 
 from myfasthtml.core.bindings import Binding
 from myfasthtml.core.commands import Command
-from myfasthtml.core.utils import merge_classes, get_default_ft_attr
+from myfasthtml.core.utils import merge_classes
 
 
 class mk:
@@ -30,27 +30,26 @@ class mk:
   @staticmethod
   def manage_command(ft, command: Command):
     if command:
-      htmx = command.get_htmx_params()
-      ft.attrs |= htmx
+      ft = command.bind_ft(ft)
     
     return ft
   
   @staticmethod
-  def manage_binding(ft, binding: Binding):
-    if binding:
-      # update the component to post on the correct route
-      htmx = binding.get_htmx_params()
-      ft.attrs |= htmx
+  def manage_binding(ft, binding: Binding, ft_attr=None, init_binding=True):
+    if not binding:
+      return ft
     
-      # update the binding with the ft
-      ft_attr = binding.ft_attr or get_default_ft_attr(ft)
-      ft_name = ft.attrs.get("name")
-      binding.bind_ft(ft, ft_name, ft_attr)  # force the ft
+    binding.bind_ft(ft, ft_attr)
+    if init_binding:
+      binding.init()
+      # as it is the first binding, remove the hx-swap-oob
+      if "hx-swap-oob" in ft.attrs:
+        del ft.attrs["hx-swap-oob"]
     
     return ft
   
   @staticmethod
-  def mk(ft, command: Command = None, binding: Binding = None):
+  def mk(ft, command: Command = None, binding: Binding = None, init_binding=True):
     ft = mk.manage_command(ft, command)
-    ft = mk.manage_binding(ft, binding)
+    ft = mk.manage_binding(ft, binding, init_binding=init_binding)
     return ft

src/myfasthtml/core/bindings.py

@@ -1,55 +1,273 @@
 import logging
 import uuid
-from typing import Optional
+from enum import Enum
+from typing import Optional, Any
 
+from fasthtml.components import Option
 from fasthtml.fastapp import fast_app
-from myutils.observable import make_observable, bind, collect_return_values
+from myutils.observable import make_observable, bind, collect_return_values, unbind
 
 from myfasthtml.core.constants import Routes, ROUTE_ROOT
-from myfasthtml.core.utils import get_default_attr
+from myfasthtml.core.utils import get_default_attr, get_default_ft_attr, is_checkbox, is_radio, is_select, is_datalist
 
 bindings_app, bindings_rt = fast_app()
 logger = logging.getLogger("Bindings")
 
 
-class Binding:
-  def __init__(self, data, attr=None, ft=None, ft_name=None, ft_attr=None):
-    """
-    Creates a new binding object between a data object used as a pivot and an HTML element.
-      The same pivot object must be used for different bindings.
-      This will allow the binding between the HTML elements
+class UpdateMode(Enum):
+  ValueChange = "ValueChange"
+  AttributePresence = "AttributePresence"
+  SelectValueChange = "SelectValueChange"
+  DatalistListChange = "DatalistListChange"
 
-    :param data: object used as a pivot
-    :param attr: attribute of the data object
-    :param ft: HTML element to bind to
-    :param ft_name: name of the HTML element to bind to (send by the form)
-    :param ft_attr: value of the attribute to bind to (send by the form)
+
+class DetectionMode(Enum):
+  ValueChange = "ValueChange"
+  AttributePresence = "AttributePresence"
+  SelectValueChange = "SelectValueChange"
+
+
+class AttrChangedDetection:
+  """
+  Base class for detecting changes in an attribute of a data object.
+  The when a modification is triggered we can
+    * Search for the attribute that is modified (usual case)
+    * Look if the attribute is present in the data object (for example when a checkbox is toggled)
+  """
+  
+  def __init__(self, attr):
+    self.attr = attr
+  
+  def matches(self, values):
+    pass
+
+
+class ValueChangedDetection(AttrChangedDetection):
+  """
+  Search for the attribute that is modified.
+  """
+  
+  def matches(self, values):
+    for key, value in values.items():
+      if key == self.attr:
+        return True, value
+    
+    return False, None
+
+
+class SelectValueChangedDetection(AttrChangedDetection):
+  """
+  Search for the attribute that is modified.
+  """
+  
+  def matches(self, values):
+    for key, value in values.items():
+      if key == self.attr:
+        return True, value
+    
+    return True, []
+
+
+class AttrPresentDetection(AttrChangedDetection):
+  """
+  Search if the attribute is present in the data object.
+  """
+  
+  def matches(self, values):
+    return True, values.get(self.attr, None)
+
+
+class FtUpdate:
+  def update(self, ft, ft_name, ft_attr, old, new, converter):
+    pass
+
+
+class ValueChangeFtUpdate(FtUpdate):
+  def update(self, ft, ft_name, ft_attr, old, new, converter):
+    # simple mode, just update the text or the attribute
+    new_to_use = converter.convert(new) if converter else new
+    if ft_attr is None:
+      ft.children = (new_to_use,)
+    else:
+      ft.attrs[ft_attr] = new_to_use
+    return ft
+
+
+class SelectValueChangeFtUpdate(FtUpdate):
+  def update(self, ft, ft_name, ft_attr, old, new, converter):
+    # simple mode, just update the text or the attribute
+    new_to_use = converter.convert(new) if converter else new
+    new_to_use = [new_to_use] if not isinstance(new_to_use, list) else new_to_use
+    for child in [c for c in ft.children if c.tag == "option"]:
+      if child.attrs.get("value", None) in new_to_use:
+        child.attrs["selected"] = "true"
+      else:
+        child.attrs.pop("selected", None)
+    return ft
+
+
+class DatalistListChangeFtUpdate(FtUpdate):
+  def update(self, ft, ft_name, ft_attr, old, new, converter):
+    new_to_use = converter.convert(new) if converter else new
+    ft.children = tuple([Option(value=v) for v in new_to_use])
+    return ft
+
+
+class AttributePresenceFtUpdate(FtUpdate):
+  def update(self, ft, ft_name, ft_attr, old, new, converter):
+    # attribute presence mode, toggle the attribute (add or remove it)
+    new_to_use = converter.convert(new) if converter else new
+    if ft_attr is None:
+      ft.children = (bool(new_to_use),)
+    else:
+      ft.attrs[ft_attr] = "true" if new_to_use else None  # FastHtml auto remove None attributes
+    return ft
+
+
+class DataConverter:
+  def convert(self, data):
+    pass
+
+
+class BooleanConverter(DataConverter):
+  def convert(self, data):
+    if data is None:
+      return False
+    
+    if isinstance(data, int):
+      return data != 0
+    
+    if str(data).lower() in ("true", "yes", "on"):
+      return True
+    
+    return False
+
+
+class ListConverter(DataConverter):
+  def convert(self, data):
+    if data is None:
+      return []
+    
+    if isinstance(data, str):
+      return data.split("\n")
+    
+    if isinstance(data, (list, set, tuple)):
+      return data
+    
+    return [data]
+
+
+class RadioConverter(DataConverter):
+  def __init__(self, radio_value):
+    self.radio_value = radio_value
+  
+  def convert(self, data):
+    return data == self.radio_value
+
+
+class Binding:
+  def __init__(self, data: Any, attr: str = None, converter: DataConverter = None):
+    """
+    Creates a new binding object between a data object and an HTML element.
+    The binding is not active until bind_ft() is called.
+
+    Args:
+        data: Object used as a pivot
+        attr: Attribute of the data object to bind
     """
     self.id = uuid.uuid4()
     self.htmx_extra = {}
     self.data = data
     self.data_attr = attr or get_default_attr(data)
-    self.ft = self._safe_ft(ft)
-    self.ft_name = ft_name
-    self.ft_attr = ft_attr
+    self.data_converter = converter
     
-    make_observable(self.data)
-    bind(self.data, self.data_attr, self.notify)
+    # UI-related attributes (configured later via bind_ft)
+    self.ft = None
+    self.ft_name = None
+    self.ft_attr = None
+    self.detection_mode = DetectionMode.ValueChange
+    self.update_mode = UpdateMode.ValueChange
     
-    # register the command
-    BindingsManager.register(self)
+    # Strategy objects (configured later)
+    self._detection = None
+    self._update = None
     
-  def bind_ft(self, ft, name, attr=None):
+    # Activation state
+    self._is_active = False
+  
+  def bind_ft(self,
+              ft,
+              attr=None,
+              name=None,
+              data_converter: DataConverter = None,
+              detection_mode: DetectionMode = None,
+              update_mode: UpdateMode = None):
     """
-    Update the elements to bind to
-    :param ft:
-    :param name:
-    :param attr:
-    :return:
+    Configure the UI element and activate the binding.
+
+    Args:
+        ft: HTML element to bind to
+        name: Name of the HTML element (sent by the form)
+        attr: Attribute of the HTML element to bind to
+        data_converter: Optional converter for data transformation
+        detection_mode: How to detect changes from UI
+        update_mode: How to update the UI element
+
+    Returns:
+        self for method chaining
     """
+    # Deactivate if already active
+    if self._is_active:
+      self.deactivate()
+    
+    if ft.tag in ["input", "textarea", "select"]:
+      # I must not force the htmx
+      if {"hx-post", "hx_post"} & set(ft.attrs.keys()):
+        raise ValueError(f"Binding '{self.id}': htmx post already set on input.")
+      
+      # update the component to post on the correct route input and forms only
+      htmx = self.get_htmx_params()
+      ft.attrs |= htmx
+    
+    # Configure UI elements
     self.ft = self._safe_ft(ft)
-    self.ft_name = name
-    self.ft_attr = attr
+    self.ft_name = name or ft.attrs.get("name")
+    self.ft_attr = attr or get_default_ft_attr(ft)
+    
+    if is_checkbox(ft):
+      default_data_converter = self.data_converter or BooleanConverter()
+      default_detection_mode = DetectionMode.AttributePresence
+      default_update_mode = UpdateMode.AttributePresence
+    elif is_radio(ft):
+      default_data_converter = self.data_converter or RadioConverter(ft.attrs["value"])
+      default_detection_mode = DetectionMode.ValueChange
+      default_update_mode = UpdateMode.AttributePresence
+    elif is_select(ft):
+      default_data_converter = self.data_converter
+      default_detection_mode = DetectionMode.SelectValueChange
+      default_update_mode = UpdateMode.SelectValueChange
+    elif is_datalist(ft):
+      default_data_converter = self.data_converter or ListConverter()
+      default_detection_mode = DetectionMode.SelectValueChange
+      default_update_mode = UpdateMode.DatalistListChange
+    else:
+      default_data_converter = self.data_converter
+      default_detection_mode = DetectionMode.ValueChange
+      default_update_mode = UpdateMode.ValueChange
+    
+    # Update optional parameters if provided
+    self.data_converter = data_converter or default_data_converter
+    self.detection_mode = detection_mode or default_detection_mode
+    self.update_mode = update_mode or default_update_mode
+    
+    # Create strategy objects
+    self._detection = self._factory(self.detection_mode)
+    self._update = self._factory(self.update_mode)
+    
+    # Activate the binding
+    self.activate()
+    
+    return self
   
   def get_htmx_params(self):
     return self.htmx_extra | {
@@ -57,20 +275,47 @@ class Binding:
         "hx-vals": f'{{"b_id": "{self.id}"}}',
     }
   
+  def init(self):
+    """
+    Initialise the UI element with the value of the data
+    :return:
+    """
+    old_value = None  # to complicated to retrieve as it depends on the nature of self.ft
+    new_value = getattr(self.data, self.data_attr)
+    self.notify(old_value, new_value)
+    return self
+  
   def notify(self, old, new):
+    """
+    Callback when the data attribute changes.
+    Updates the UI element accordingly.
+
+    Args:
+        old: Previous value
+        new: New value
+
+    Returns:
+        Updated ft element
+    """
+    if not self._is_active:
+      logger.warning(f"Binding '{self.id}' received notification but is not active")
+      return None
+    
     logger.debug(f"Binding '{self.id}': Changing from '{old}' to '{new}'")
-    if self.ft_attr is None:
-      self.ft.children = (new,)
-    else:
-      self.ft.attrs[self.ft_attr] = new
+    self.ft = self._update.update(self.ft, self.ft_name, self.ft_attr, old, new, self.data_converter)
     
     self.ft.attrs["hx-swap-oob"] = "true"
     return self.ft
   
   def update(self, values: dict):
+    """
+    Called by the FastHTML router when a request is received.
+    :param values:
+    :return: the list of updated elements (all elements that are bound to this binding)
+    """
     logger.debug(f"Binding '{self.id}': Updating with {values=}.")
-    for key, value in values.items():
-      if key == self.ft_name:
+    matches, value = self._detection.matches(values)
+    if matches:
       setattr(self.data, self.data_attr, value)
       res = collect_return_values(self.data)
       return res
@@ -79,6 +324,53 @@ class Binding:
       logger.debug(f"Nothing to trigger in {values}.")
       return None
   
+  def activate(self):
+    """
+    Activate the binding by setting up observers and registering it.
+    Should only be called after the binding is fully configured.
+
+    Raises:
+        ValueError: If the binding is not fully configured
+    """
+    if self._is_active:
+      logger.warning(f"Binding '{self.id}' is already active")
+      return
+    
+    # Validate configuration
+    self._validate_configuration()
+    
+    # Setup observable
+    make_observable(self.data)
+    bind(self.data, self.data_attr, self.notify)
+    
+    # Register in manager
+    BindingsManager.register(self)
+    
+    # Mark as active
+    self._is_active = True
+    
+    logger.debug(f"Binding '{self.id}' activated for {self.data_attr}")
+  
+  def deactivate(self):
+    """
+    Deactivate the binding by removing observers and unregistering it.
+    Can be called multiple times safely.
+    """
+    if not self._is_active:
+      logger.debug(f"Binding '{self.id}' is not active, nothing to deactivate")
+      return
+    
+    # Remove observer
+    unbind(self.data, self.data_attr, self.notify)
+    
+    # Unregister from manager
+    BindingsManager.unregister(self.id)
+    
+    # Mark as inactive
+    self._is_active = False
+    
+    logger.debug(f"Binding '{self.id}' deactivated")
+  
   @staticmethod
   def _safe_ft(ft):
     """
@@ -93,11 +385,56 @@ class Binding:
       ft.attrs["id"] = str(uuid.uuid4())
     return ft
   
+  def _factory(self, mode):
+    if mode == DetectionMode.ValueChange:
+      return ValueChangedDetection(self.ft_name)
+    
+    elif mode == DetectionMode.AttributePresence:
+      return AttrPresentDetection(self.ft_name)
+    
+    elif mode == DetectionMode.SelectValueChange:
+      return SelectValueChangedDetection(self.ft_name)
+    
+    elif mode == UpdateMode.ValueChange:
+      return ValueChangeFtUpdate()
+    
+    elif mode == UpdateMode.AttributePresence:
+      return AttributePresenceFtUpdate()
+    
+    elif mode == UpdateMode.SelectValueChange:
+      return SelectValueChangeFtUpdate()
+    
+    elif mode == UpdateMode.DatalistListChange:
+      return DatalistListChangeFtUpdate()
+    
+    else:
+      raise ValueError(f"Invalid detection mode: {mode}")
+  
+  def _validate_configuration(self):
+    """
+    Validate that the binding is fully configured before activation.
+
+    Raises:
+        ValueError: If required configuration is missing
+    """
+    if self.ft is None:
+      raise ValueError(f"Binding '{self.id}': ft element is required")
+    
+    # if self.ft_name is None:
+    #   raise ValueError(f"Binding '{self.id}': ft_name is required")
+    
+    if self._detection is None:
+      raise ValueError(f"Binding '{self.id}': detection strategy not initialized")
+    
+    if self._update is None:
+      raise ValueError(f"Binding '{self.id}': update strategy not initialized")
+  
   def htmx(self, trigger=None):
     if trigger:
       self.htmx_extra["hx-trigger"] = trigger
     return self
 
+
 class BindingsManager:
   bindings = {}
   
@@ -105,6 +442,17 @@ class BindingsManager:
   def register(binding: Binding):
     BindingsManager.bindings[str(binding.id)] = binding
   
+  @staticmethod
+  def unregister(binding_id: str):
+    """
+    Unregister a binding from the manager.
+
+    Args:
+        binding_id: ID of the binding to unregister
+    """
+    if str(binding_id) in BindingsManager.bindings:
+      del BindingsManager.bindings[str(binding_id)]
+  
   @staticmethod
   def get_binding(binding_id: str) -> Optional[Binding]:
     return BindingsManager.bindings.get(str(binding_id))

src/myfasthtml/core/commands.py

@@ -1,6 +1,8 @@
 import uuid
 from typing import Optional
 
+from myutils.observable import NotObservableError, ObservableEvent, add_event_listener, remove_event_listener
+
 from myfasthtml.core.constants import Routes, ROUTE_ROOT
 
 
@@ -25,13 +27,14 @@ class BaseCommand:
     self.id = uuid.uuid4()
     self.name = name
     self.description = description
-    self.htmx_extra = {}
+    self._htmx_extra = {}
+    self._bindings = []
     
     # register the command
     CommandsManager.register(self)
   
   def get_htmx_params(self):
-    return self.htmx_extra | {
+    return self._htmx_extra | {
         "hx-post": f"{ROUTE_ROOT}{Routes.Commands}",
         "hx-vals": f'{{"c_id": "{self.id}"}}',
     }
@@ -39,9 +42,46 @@ class BaseCommand:
   def execute(self):
     raise NotImplementedError
   
-  def htmx(self, target=None):
-    if target:
-      self.htmx_extra["hx-target"] = target
+  def htmx(self, target="this", swap="innerHTML"):
+    if target is None:
+      self._htmx_extra["hx-swap"] = "none"
+    elif target != "this":
+      self._htmx_extra["hx-target"] = target
+    
+    if swap is None:
+      self._htmx_extra["hx-swap"] = "none"
+    elif swap != "innerHTML":
+      self._htmx_extra["hx-swap"] = swap
+    return self
+  
+  def bind_ft(self, ft):
+    """
+    Update the FT with the command's HTMX parameters.
+
+    :param ft:
+    :return:
+    """
+    htmx = self.get_htmx_params()
+    ft.attrs |= htmx
+    return ft
+  
+  def bind(self, data):
+    """
+    Attach a binding to the command.
+    When done, if a binding is triggered during the execution of the command,
+    the results of the binding will be passed to the command's execute() method.
+    :param data:
+    :return:
+    """
+    if not hasattr(data, '_listeners'):
+      raise NotObservableError(
+        f"Object must be made observable with make_observable() before binding"
+      )
+    self._bindings.append(data)
+    
+    # by default, remove the swap on the attached element when binding is used
+    self._htmx_extra["hx-swap"] = "none"
+    
     return self
 
 
@@ -71,7 +111,26 @@ class Command(BaseCommand):
     self.kwargs = kwargs
   
   def execute(self):
-    return self.callback(*self.args, **self.kwargs)
+    ret_from_bindings = []
+    
+    def binding_result_callback(attr, old, new, results):
+      ret_from_bindings.extend(results)
+    
+    for data in self._bindings:
+      add_event_listener(ObservableEvent.AFTER_PROPERTY_CHANGE, data, "", binding_result_callback)
+    
+    ret = self.callback(*self.args, **self.kwargs)
+    
+    for data in self._bindings:
+      remove_event_listener(ObservableEvent.AFTER_PROPERTY_CHANGE, data, "", binding_result_callback)
+    
+    if not ret_from_bindings:
+      return ret
+    
+    if isinstance(ret, list):
+      return ret + ret_from_bindings
+    else:
+      return [ret] + ret_from_bindings
   
   def __str__(self):
     return f"Command({self.name})"

src/myfasthtml/core/utils.py

@@ -1,9 +1,12 @@
 import logging
 
+from bs4 import Tag
+from fastcore.xml import FT
 from fasthtml.fastapp import fast_app
-from starlette.routing import Mount, Route
+from starlette.routing import Mount
 
 from myfasthtml.core.constants import Routes, ROUTE_ROOT
+from myfasthtml.test.MyFT import MyFT
 
 utils_app, utils_rt = fast_app()
 logger = logging.getLogger("Commands")
@@ -57,12 +60,15 @@ def merge_classes(*args):
 
 
 def debug_routes(app):
+  def _debug_routes(_app, _route, prefix=""):
+    if isinstance(_route, Mount):
+      for sub_route in _route.app.router.routes:
+        _debug_routes(_app, sub_route, prefix=_route.path)
+    else:
+      print(f"path={prefix}{_route.path}, methods={_route.methods}, endpoint={_route.endpoint}")
+  
   for route in app.router.routes:
-    if isinstance(route, Mount):
-      for sub_route in route.app.router.routes:
-        print(f"path={route.path}{sub_route.path}, method={sub_route.methods}, endpoint={sub_route.endpoint}")
-    elif isinstance(route, Route):
-      print(f"path={route.path}, methods={route.methods}, endpoint={route.endpoint}")
+    _debug_routes(app, route)
 
 
 def mount_utils(app):
@@ -101,8 +107,59 @@ def get_default_attr(data):
   return next(iter(all_attrs))
 
 
+def is_checkbox(elt):
+  if isinstance(elt, (FT, MyFT)):
+    return elt.tag == "input" and elt.attrs.get("type", None) == "checkbox"
+  elif isinstance(elt, Tag):
+    return elt.name == "input" and elt.attrs.get("type", None) == "checkbox"
+  else:
+    return False
+
+
+def is_radio(elt):
+  if isinstance(elt, (FT, MyFT)):
+    return elt.tag == "input" and elt.attrs.get("type", None) == "radio"
+  elif isinstance(elt, Tag):
+    return elt.name == "input" and elt.attrs.get("type", None) == "radio"
+  else:
+    return False
+
+
+def is_select(elt):
+  if isinstance(elt, (FT, MyFT)):
+    return elt.tag == "select"
+  elif isinstance(elt, Tag):
+    return elt.name == "select"
+  else:
+    return False
+
+
+def is_datalist(elt):
+  if isinstance(elt, (FT, MyFT)):
+    return elt.tag == "datalist"
+  elif isinstance(elt, Tag):
+    return elt.name == "datalist"
+  else:
+    return False
+
+
+def quoted_str(s):
+  if s is None:
+    return "None"
+  
+  if isinstance(s, str):
+    if "'" in s and '"' in s:
+      return f'"{s.replace('"', '\\"')}"'
+    elif '"' in s:
+      return f"'{s}'"
+    else:
+      return f'"{s}"'
+  
+  return str(s)
+
+
 @utils_rt(Routes.Commands)
-def post(session: str, c_id: str):
+def post(session, c_id: str):
   """
   Default routes for all commands.
   :param session:
@@ -119,7 +176,7 @@ def post(session: str, c_id: str):
 
 
 @utils_rt(Routes.Bindings)
-def post(session: str, b_id: str, values: dict):
+def post(session, b_id: str, values: dict):
   """
   Default routes for all bindings.
   :param session:

src/myfasthtml/examples/binding_checkbox.py

@@ -0,0 +1,51 @@
+import logging
+from dataclasses import dataclass
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding, BooleanConverter
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+logging.basicConfig(
+  level=logging.DEBUG,  # Set logging level to DEBUG
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',  # Log format
+  datefmt='%Y-%m-%d %H:%M:%S',  # Timestamp format
+)
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: str = "Hello World"
+  checked: bool = False
+
+
+data = Data()
+
+
+@rt("/set_checkbox")
+def post(check_box_name: str = None):
+  print(check_box_name)
+
+
+@rt("/")
+def index():
+  return Div(
+    mk.mk(Input(name="checked_name", type="checkbox"), binding=Binding(data, attr="checked")),
+    mk.mk(Label("Text"), binding=Binding(data, attr="checked", converter=BooleanConverter())),
+  )
+
+
+@rt("/test_checkbox_htmx")
+def get():
+  check_box = Input(type="checkbox", name="check_box_name", hx_post="/set_checkbox")
+  return check_box
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_datalist.py

@@ -0,0 +1,66 @@
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.commands import Command
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+logging.basicConfig(
+  level=logging.DEBUG,  # Set logging level to DEBUG
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',  # Log format
+  datefmt='%Y-%m-%d %H:%M:%S',  # Timestamp format
+)
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+def add_suggestion():
+  nb = len(data.value)
+  data.value = data.value + [f"suggestion{nb}"]
+
+
+def remove_suggestion():
+  if len(data.value) > 0:
+    data.value = data.value[:-1]
+
+
+data = Data(["suggestion0", "suggestion1", "suggestion2"])
+
+
+@rt("/")
+def get():
+  datalist = Datalist(
+    id="suggestions"
+  )
+  input_elt = Input(name="input_name", list="suggestions")
+  label_elt = Label()
+  
+  mk.manage_binding(datalist, Binding(data))
+  mk.manage_binding(label_elt, Binding(data))
+  
+  add_button = mk.button("Add", command=Command("Add", "Add a suggestion", add_suggestion).bind(data))
+  remove_button = mk.button("Remove", command=Command("Remove", "Remove a suggestion", remove_suggestion).bind(data))
+  
+  return Div(
+    add_button,
+    remove_button,
+    input_elt,
+    datalist,
+    label_elt
+  )
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_input.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+data = Data()
+
+
+@rt("/")
+def get():
+  return Div(
+    mk.mk(Input(name="input_name"), binding=Binding(data, attr="value").htmx(trigger="input changed")),
+    mk.mk(Label("Text"), binding=Binding(data, attr="value"))
+  )
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_radio.py

@@ -0,0 +1,47 @@
+import logging
+from dataclasses import dataclass
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+logging.basicConfig(
+  level=logging.DEBUG,  # Set logging level to DEBUG
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',  # Log format
+  datefmt='%Y-%m-%d %H:%M:%S',  # Timestamp format
+)
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: str = "Hello World"
+  checked: bool = False
+
+
+data = Data()
+
+
+@rt("/")
+def get():
+  radio1 = Input(type="radio", name="radio_name", value="option1")
+  radio2 = Input(type="radio", name="radio_name", value="option2", checked=True)
+  radio3 = Input(type="radio", name="radio_name", value="option3")
+  label_elt = Label("hi hi hi !")
+  
+  mk.manage_binding(radio1, Binding(data))
+  mk.manage_binding(radio2, Binding(data))
+  mk.manage_binding(radio3, Binding(data))
+  mk.manage_binding(label_elt, Binding(data))
+  
+  return radio1, radio2, radio3, label_elt
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_range.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+data = Data(50)
+
+
+@rt("/")
+def get():
+  range_elt = Input(
+    type="range",
+    name="range_name",
+    min="0",
+    max="100",
+    value="50"
+  )
+  label_elt = Label()
+  mk.manage_binding(range_elt, Binding(data))
+  mk.manage_binding(label_elt, Binding(data))
+  return range_elt, label_elt
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_select.py

@@ -0,0 +1,46 @@
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+logging.basicConfig(
+  level=logging.DEBUG,  # Set logging level to DEBUG
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',  # Log format
+  datefmt='%Y-%m-%d %H:%M:%S',  # Timestamp format
+)
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+data = Data()
+
+
+@rt("/")
+def get():
+  select_elt = Select(
+    Option("Option 1", value="option1"),
+    Option("Option 2", value="option2"),
+    Option("Option 3", value="option3"),
+    name="select_name"
+  )
+  label_elt = Label()
+  mk.manage_binding(select_elt, Binding(data), init_binding=False)
+  mk.manage_binding(label_elt, Binding(data))
+  return select_elt, label_elt
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_select_multiple.py

@@ -0,0 +1,47 @@
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+logging.basicConfig(
+  level=logging.DEBUG,  # Set logging level to DEBUG
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',  # Log format
+  datefmt='%Y-%m-%d %H:%M:%S',  # Timestamp format
+)
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+data = Data()
+
+
+@rt("/")
+def get():
+  select_elt = Select(
+    Option("Option 1", value="option1"),
+    Option("Option 2", value="option2"),
+    Option("Option 3", value="option3"),
+    name="select_name",
+    multiple=True
+  )
+  label_elt = Label()
+  mk.manage_binding(select_elt, Binding(data), init_binding=False)
+  mk.manage_binding(label_elt, Binding(data))
+  return select_elt, label_elt
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/examples/binding_textarea.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Any
+
+from fasthtml import serve
+from fasthtml.components import *
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.core.utils import debug_routes
+from myfasthtml.myfastapp import create_app
+
+app, rt = create_app(protect_routes=False)
+
+
+@dataclass
+class Data:
+  value: Any = "Hello World"
+
+
+data = Data()
+
+
+@rt("/")
+def get():
+  return Div(
+    mk.mk(Textarea(name="input_name"), binding=Binding(data, attr="value").htmx(trigger="input changed")),
+    mk.mk(Label("Text"), binding=Binding(data, attr="value"))
+  )
+
+
+if __name__ == "__main__":
+  debug_routes(app)
+  serve(port=5002)

src/myfasthtml/test/MyFT.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class MyFT:
+  tag: str
+  attrs: dict
+  children: list['MyFT'] = field(default_factory=list)
+  text: str | None = None

src/myfasthtml/test/matcher.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 
 from fastcore.basics import NotStr
 
+from myfasthtml.core.utils import quoted_str
 from myfasthtml.test.testclient import MyFT
 
 
@@ -14,10 +15,13 @@ class Predicate:
     raise NotImplementedError
   
   def __str__(self):
-    return f"{self.__class__.__name__}({self.value})"
+    return f"{self.__class__.__name__}({self.value if self.value is not None else ''})"
+  
+  def __repr__(self):
+    return f"{self.__class__.__name__}({self.value if self.value is not None else ''})"
   
   def __eq__(self, other):
-    if not isinstance(other, Predicate):
+    if type(self) is not type(other):
       return False
     return self.value == other.value
   
@@ -25,7 +29,15 @@ class Predicate:
     return hash(self.value)
 
 
-class StartsWith(Predicate):
+class AttrPredicate(Predicate):
+  """
+  Predicate that validates an attribute value.
+  It's given as a value of an attribute.
+  """
+  pass
+
+
+class StartsWith(AttrPredicate):
   def __init__(self, value):
     super().__init__(value)
   
@@ -33,7 +45,7 @@ class StartsWith(Predicate):
     return actual.startswith(self.value)
 
 
-class Contains(Predicate):
+class Contains(AttrPredicate):
   def __init__(self, value):
     super().__init__(value)
   
@@ -41,7 +53,7 @@ class Contains(Predicate):
     return self.value in actual
 
 
-class DoesNotContain(Predicate):
+class DoesNotContain(AttrPredicate):
   def __init__(self, value):
     super().__init__(value)
   
@@ -49,16 +61,56 @@ class DoesNotContain(Predicate):
     return self.value not in actual
 
 
+class AnyValue(AttrPredicate):
+  """
+  True is the attribute is present and the value is not None.
+  """
+  
+  def __init__(self):
+    super().__init__(None)
+  
+  def validate(self, actual):
+    return actual is not None
+
+
+class ChildrenPredicate(Predicate):
+  """
+  Predicate given as a child of an element.
+  """
+  
+  def to_debug(self, element):
+    return element
+
+
+class Empty(ChildrenPredicate):
+  def __init__(self):
+    super().__init__(None)
+  
+  def validate(self, actual):
+    return len(actual.children) == 0 and len(actual.attrs) == 0
+
+
+class AttributeForbidden(ChildrenPredicate):
+  """
+  To validate that an attribute is not present in an element.
+  """
+  
+  def __init__(self, value):
+    super().__init__(value)
+  
+  def validate(self, actual):
+    return self.value not in actual.attrs or actual.attrs[self.value] is None
+  
+  def to_debug(self, element):
+    element.attrs[self.value] = "** NOT ALLOWED **"
+    return element
+
+
 @dataclass
 class DoNotCheck:
   desc: str = None
 
 
-@dataclass
-class Empty:
-  desc: str = None
-
-
 class ErrorOutput:
   def __init__(self, path, element, expected):
     self.path = path
@@ -77,7 +129,7 @@ class ErrorOutput:
     return item, None, None
   
   def __str__(self):
-    self.compute()
+    return f"ErrorOutput({self.output})"
   
   def compute(self):
     # first render the path hierarchy
@@ -99,31 +151,32 @@ class ErrorOutput:
         self._add_to_output(error_str)
       
       # render the children
-      if len(self.expected.children) > 0:
+      expected_children = [c for c in self.expected.children if not isinstance(c, ChildrenPredicate)]
+      if len(expected_children) > 0:
         self.indent += "  "
         element_index = 0
-        for expected_child in self.expected.children:
-          if hasattr(expected_child, "tag"):
-            if element_index < len(self.element.children):
+        for expected_child in expected_children:
+          if element_index >= len(self.element.children):
+            # When there are fewer children than expected, we display a placeholder
+            child_str = "! ** MISSING ** !"
+            self._add_to_output(child_str)
+            element_index += 1
+            continue
+          
           # display the child
           element_child = self.element.children[element_index]
           child_str = self._str_element(element_child, expected_child, keep_open=False)
           self._add_to_output(child_str)
           
-              # manage errors in children
+          # manage errors (only when the expected is a FT element
+          if hasattr(expected_child, "tag"):
             child_error_str = self._detect_error(element_child, expected_child)
             if child_error_str:
               self._add_to_output(child_error_str)
+          
+          # continue
           element_index += 1
         
-            else:
-              # When there are fewer children than expected, we display a placeholder
-              child_str = "! ** MISSING ** !"
-              self._add_to_output(child_str)
-          
-          else:
-            self._add_to_output(expected_child)
-        
         self.indent = self.indent[:-2]
         self._add_to_output(")")
     else:
@@ -142,12 +195,12 @@ class ErrorOutput:
     if expected is None:
       expected = element
     
+    if hasattr(element, "tag"):
       # the attributes are compared to the expected element
       elt_attrs = {attr_name: element.attrs.get(attr_name, "** MISSING **") for attr_name in
                    [attr_name for attr_name in expected.attrs if attr_name is not None]}
-    elt_attrs_str = " ".join(f'"{attr_name}"="{attr_value}"' for attr_name, attr_value in elt_attrs.items())
       
-    #
+      elt_attrs_str = " ".join(f'"{attr_name}"="{attr_value}"' for attr_name, attr_value in elt_attrs.items())
       tag_str = f"({element.tag} {elt_attrs_str}"
       
       # manage the closing tag
@@ -157,10 +210,13 @@ class ErrorOutput:
         tag_str += "..." if elt_attrs_str == "" else " ..."
       else:
         # close the tag if there are no children
-      if len(element.children) == 0:  tag_str += ")"
-    
+        not_special_children = [c for c in element.children if not isinstance(c, Predicate)]
+        if len(not_special_children) == 0:  tag_str += ")"
       return tag_str
     
+    else:
+      return quoted_str(element)
+  
   def _detect_error(self, element, expected):
     if hasattr(expected, "tag") and hasattr(element, "tag"):
       tag_str = len(element.tag) * (" " if element.tag == expected.tag else "^")
@@ -307,16 +363,18 @@ def matches(actual, expected, path=""):
                                                   _actual=actual.tag,
                                                   _expected=expected.tag)
     
-    # special case when the expected element is empty
-    if len(expected.children) > 0 and isinstance(expected.children[0], Empty):
-      assert len(actual.children) == 0, _error_msg("Actual is not empty:", _actual=actual)
-      assert len(actual.attrs) == 0, _error_msg("Actual is not empty:", _actual=actual)
-      return True
+    # special conditions
+    for predicate in [c for c in expected.children if isinstance(c, ChildrenPredicate)]:
+      assert predicate.validate(actual), \
+        _error_msg(f"The condition '{predicate}' is not satisfied.",
+                   _actual=actual,
+                   _expected=predicate.to_debug(expected))
     
     # compare the attributes
     for expected_attr, expected_value in expected.attrs.items():
       assert expected_attr in actual.attrs, _error_msg(f"'{expected_attr}' is not found in Actual.",
-                                                       _actual=actual.attrs)
+                                                       _actual=actual,
+                                                       _expected=expected)
       
       if isinstance(expected_value, Predicate):
         assert expected_value.validate(actual.attrs[expected_attr]), \
@@ -327,14 +385,15 @@ def matches(actual, expected, path=""):
       else:
         assert actual.attrs[expected_attr] == expected.attrs[expected_attr], \
           _error_msg(f"The values are different for '{expected_attr}': ",
-                     _actual=actual.attrs[expected_attr],
-                     _expected=expected.attrs[expected_attr])
+                     _actual=actual,
+                     _expected=expected)
     
     # compare the children
-    if len(actual.children) < len(expected.children):
+    expected_children = [c for c in expected.children if not isinstance(c, Predicate)]
+    if len(actual.children) < len(expected_children):
       _assert_error("Actual is lesser than expected: ", _actual=actual, _expected=expected)
     
-    for actual_child, expected_child in zip(actual.children, expected.children):
+    for actual_child, expected_child in zip(actual.children, expected_children):
       assert matches(actual_child, expected_child, path=path)
   
   else:

src/myfasthtml/test/testclient.py

@@ -1,7 +1,5 @@
-import dataclasses
 import json
 import uuid
-from dataclasses import dataclass
 from typing import Self
 
 from bs4 import BeautifulSoup, Tag
@@ -11,6 +9,7 @@ from starlette.responses import Response
 from starlette.testclient import TestClient
 
 from myfasthtml.core.utils import mount_utils
+from myfasthtml.test.MyFT import MyFT
 
 verbs = {
     'hx_get': 'GET',
@@ -21,12 +20,11 @@ verbs = {
 }
 
 
-@dataclass
-class MyFT:
-  tag: str
-  attrs: dict
-  children: list['MyFT'] = dataclasses.field(default_factory=list)
-  text: str | None = None
+class DoNotSendCls:
+  pass
+
+
+DoNotSend = DoNotSendCls()
 
 
 class TestableElement:
@@ -209,7 +207,7 @@ class TestableElement:
       # Check for explicit association via 'for' attribute
       label_for = label.get('for')
       if label_for:
-        input_field = self.element.find('input', id=label_for)
+        input_field = self.element.find(id=label_for)
         if input_field:
           input_name = self._get_input_identifier(input_field, unnamed_counter)
           if input_name.startswith('unnamed_'):
@@ -309,7 +307,7 @@ class TestableElement:
           self.fields[name] = raw_value
         elif name not in self.fields:
           # If no radio is checked yet, don't set a default
-          pass
+          self.fields[name] = None
       
       elif input_type == 'number':
         # Number: int or float based on value
@@ -327,7 +325,7 @@ class TestableElement:
       
       # Extract all options
       options = []
-      selected_value = None
+      selected_value = []
       
       for option in select_field.find_all('option'):
         option_value = option.get('value', option.get_text(strip=True))
@@ -340,17 +338,29 @@ class TestableElement:
         
         # Track selected option
         if option.has_attr('selected'):
-          selected_value = option_value
+          selected_value.append(option_value)
       
       # Store options list
       self.select_fields[name] = options
       
       # Store selected value (or first option if none selected)
-      if selected_value is not None:
+      is_multiple = select_field.has_attr('multiple')
+      if is_multiple:
         self.fields[name] = selected_value
+      else:
+        if len(selected_value) > 0:
+          self.fields[name] = selected_value[-1]
         elif options:
           self.fields[name] = options[0]['value']
     
+    # Process textarea fields
+    for textarea_field in self.element.find_all('textarea'):
+      name = textarea_field.get('name')
+      if not name:
+        continue
+      
+      self.fields[name] = textarea_field.get_text(strip=True)
+  
   @staticmethod
   def _get_input_identifier(input_field, counter):
     """
@@ -605,200 +615,11 @@ class TestableForm(TestableElement):
       data=self.fields
     )
 
-  # def _translate(self, field):
-  #   """
-  #   Translate a given field using a predefined mapping. If the field is not found
-  #   in the mapping, the original field is returned unmodified.
-  #
-  #   :param field: The field name to be translated.
-  #   :type field: str
-  #   :return: The translated field name if present in the mapping, or the original
-  #       field name if no mapping exists for it.
-  #   :rtype: str
-  #   """
-  #   return self.fields_mapping.get(field, field)
-  #
-  # def _update_fields_mapping(self):
-  #   """
-  #   Build a mapping between label text and input field names.
-  #
-  #   This method finds all labels in the form and associates them with their
-  #   corresponding input fields using the following priority order:
-  #   1. Explicit association via 'for' attribute matching input 'id'
-  #   2. Implicit association (label contains the input)
-  #   3. Parent-level association with 'for'/'id'
-  #   4. Proximity association (siblings in same parent)
-  #   5. No label (use input name as key)
-  #
-  #   The mapping is stored in self.fields_mapping as {label_text: input_name}.
-  #   For inputs without a name, the id is used. If neither exists, a generic
-  #   key like "unnamed_0" is generated.
-  #   """
-  #   self.fields_mapping = {}
-  #   processed_inputs = set()
-  #   unnamed_counter = 0
-  #
-  #   # Get all inputs in the form
-  #   all_inputs = self.form.find_all('input')
-  #
-  #   # Priority 1 & 2: Explicit association (for/id) and implicit (nested)
-  #   for label in self.form.find_all('label'):
-  #     label_text = label.get_text(strip=True)
-  #
-  #     # Check for explicit association via 'for' attribute
-  #     label_for = label.get('for')
-  #     if label_for:
-  #       input_field = self.form.find('input', id=label_for)
-  #       if input_field:
-  #         input_name = self._get_input_identifier(input_field, unnamed_counter)
-  #         if input_name.startswith('unnamed_'):
-  #           unnamed_counter += 1
-  #         self.fields_mapping[label_text] = input_name
-  #         processed_inputs.add(id(input_field))
-  #         continue
-  #
-  #     # Check for implicit association (label contains input)
-  #     input_field = label.find('input')
-  #     if input_field:
-  #       input_name = self._get_input_identifier(input_field, unnamed_counter)
-  #       if input_name.startswith('unnamed_'):
-  #         unnamed_counter += 1
-  #       self.fields_mapping[label_text] = input_name
-  #       processed_inputs.add(id(input_field))
-  #       continue
-  #
-  #   # Priority 3 & 4: Parent-level associations
-  #   for label in self.form.find_all('label'):
-  #     label_text = label.get_text(strip=True)
-  #
-  #     # Skip if this label was already processed
-  #     if label_text in self.fields_mapping:
-  #       continue
-  #
-  #     parent = label.parent
-  #     if parent:
-  #       input_found = False
-  #
-  #       # Priority 3: Look for sibling input with matching for/id
-  #       label_for = label.get('for')
-  #       if label_for:
-  #         for sibling in parent.find_all('input'):
-  #           if sibling.get('id') == label_for and id(sibling) not in processed_inputs:
-  #             input_name = self._get_input_identifier(sibling, unnamed_counter)
-  #             if input_name.startswith('unnamed_'):
-  #               unnamed_counter += 1
-  #             self.fields_mapping[label_text] = input_name
-  #             processed_inputs.add(id(sibling))
-  #             input_found = True
-  #             break
-  #
-  #       # Priority 4: Fallback to proximity if no input found yet
-  #       if not input_found:
-  #         for sibling in parent.find_all('input'):
-  #           if id(sibling) not in processed_inputs:
-  #             input_name = self._get_input_identifier(sibling, unnamed_counter)
-  #             if input_name.startswith('unnamed_'):
-  #               unnamed_counter += 1
-  #             self.fields_mapping[label_text] = input_name
-  #             processed_inputs.add(id(sibling))
-  #             break
-  #
-  #   # Priority 5: Inputs without labels
-  #   for input_field in all_inputs:
-  #     if id(input_field) not in processed_inputs:
-  #       input_name = self._get_input_identifier(input_field, unnamed_counter)
-  #       if input_name.startswith('unnamed_'):
-  #         unnamed_counter += 1
-  #       self.fields_mapping[input_name] = input_name
-  #
-  # @staticmethod
-  # def _get_input_identifier(input_field, counter):
-  #   """
-  #   Get the identifier for an input field.
-  #
-  #   Args:
-  #       input_field: The BeautifulSoup Tag object representing the input.
-  #       counter: Current counter for unnamed inputs.
-  #
-  #   Returns:
-  #       The input name, id, or a generated "unnamed_X" identifier.
-  #   """
-  #   if input_field.get('name'):
-  #     return input_field['name']
-  #   elif input_field.get('id'):
-  #     return input_field['id']
-  #   else:
-  #     return f"unnamed_{counter}"
-  #
-  # @staticmethod
-  # def _convert_number(value):
-  #   """
-  #   Convert a string value to int or float.
-  #
-  #   Args:
-  #       value: String value to convert.
-  #
-  #   Returns:
-  #       int, float, or empty string if conversion fails.
-  #   """
-  #   if not value or value.strip() == '':
-  #     return ''
-  #
-  #   try:
-  #     # Try float first to detect decimal numbers
-  #     if '.' in value or 'e' in value.lower():
-  #       return float(value)
-  #     else:
-  #       return int(value)
-  #   except ValueError:
-  #     return value
-  #
-  # @staticmethod
-  # def _convert_value(value):
-  #   """
-  #   Analyze and convert a value to its appropriate type.
-  #
-  #   Conversion priority:
-  #   1. Boolean keywords (true/false)
-  #   2. Float (contains decimal point)
-  #   3. Int (numeric)
-  #   4. Empty string
-  #   5. String (default)
-  #
-  #   Args:
-  #       value: String value to convert.
-  #
-  #   Returns:
-  #       Converted value with appropriate type (bool, float, int, or str).
-  #   """
-  #   if not value or value.strip() == '':
-  #     return ''
-  #
-  #   value_lower = value.lower().strip()
-  #
-  #   # Check for boolean
-  #   if value_lower in ('true', 'false'):
-  #     return value_lower == 'true'
-  #
-  #   # Check for numeric values
-  #   try:
-  #     # Check for float (has decimal point or scientific notation)
-  #     if '.' in value or 'e' in value_lower:
-  #       return float(value)
-  #     # Try int
-  #     else:
-  #       return int(value)
-  #   except ValueError:
-  #     pass
-  #
-  #   # Default to string
-  #   return value
-
 
 class TestableControl(TestableElement):
   def __init__(self, client, source, tag):
-    super().__init__(client, source, "input")
-    assert len(self.fields) <= 1
+    super().__init__(client, source, tag)
+    assert len(self.fields) == 1
     self._input_name = next(iter(self.fields))
   
   @property
@@ -811,7 +632,8 @@ class TestableControl(TestableElement):
   
   def _send_value(self):
     if self._input_name and self._support_htmx():
-      return self._send_htmx_request(data={self._input_name: self.value})
+      value = {} if self.value is DoNotSend else {self._input_name: self.value}
+      return self._send_htmx_request(data=value)
     return None
 
 
@@ -833,17 +655,468 @@ class TestableCheckbox(TestableControl):
     return self.fields[self._input_name] == True
   
   def check(self):
-    self.fields[self._input_name] = True
+    self.fields[self._input_name] = "on"
     return self._send_value()
   
   def uncheck(self):
-    self.fields[self._input_name] = False
+    self.fields[self._input_name] = DoNotSend
     return self._send_value()
   
   def toggle(self):
-    self.fields[self._input_name] = not self.fields[self._input_name]
+    if self.fields[self._input_name] == "on":
+      return self.uncheck()
+    else:
+      return self.check()
+
+
+class TestableTextarea(TestableControl):
+  """
+  Represents a textarea element that can be interacted with in tests.
+
+  Textareas are similar to text inputs but support multi-line text.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable textarea.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    # Parse as textarea element
+    super().__init__(client, source, "textarea")
+  
+  def send(self, value):
+    """
+    Set the textarea value and trigger HTMX update if configured.
+
+    Args:
+        value: The text value to set (can be multi-line string).
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    self.fields[self.name] = value
     return self._send_value()
   
+  def append(self, text):
+    """
+    Append text to the current textarea value.
+
+    Args:
+        text: Text to append.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    current_value = self.fields.get(self.name, '')
+    self.fields[self.name] = current_value + text
+    return self._send_value()
+  
+  def clear(self):
+    """
+    Clear the textarea content.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    self.fields[self.name] = ''
+    return self._send_value()
+
+
+class TestableSelect(TestableControl):
+  """
+  Represents a select dropdown element that can be interacted with in tests.
+
+  Supports both single and multiple selection modes.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable select element.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    # Parse as select element
+    super().__init__(client, source, "select")
+    self._is_multiple = self.my_ft.attrs.get('multiple') is not None
+  
+  @property
+  def is_multiple(self):
+    """Check if this is a multiple selection dropdown."""
+    return self._is_multiple
+  
+  @property
+  def options(self):
+    """
+    Get all available options for this select.
+
+    Returns:
+        List of dicts with 'value' and 'text' keys.
+    """
+    return self.select_fields.get(self.name, [])
+  
+  def select(self, value):
+    """
+    Select an option by value.
+
+    Args:
+        value: The value of the option to select (not the text).
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+
+    Raises:
+        ValueError: If the value is not in the available options.
+    """
+    # Validate the value exists in options
+    available_values = [opt['value'] for opt in self.options]
+    if value not in available_values:
+      raise ValueError(
+        f"Value '{value}' not found in select options. "
+        f"Available values: {available_values}"
+      )
+    
+    if self.is_multiple:
+      # For multiple select, value should be a list
+      current = self.fields.get(self.name, [])
+      if not isinstance(current, list):
+        current = [current] if current else []
+      if value not in current:
+        current.append(value)
+      self.fields[self.name] = current[0] if len(current) == 1 else current  # it's not a list when only one is selected
+    else:
+      # For single select, just set the value
+      self.fields[self.name] = value
+    
+    return self._send_value()
+  
+  def select_by_text(self, text):
+    """
+    Select an option by its visible text.
+
+    Args:
+        text: The visible text of the option to select.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+
+    Raises:
+        ValueError: If the text is not found in options.
+    """
+    # Find the value corresponding to this text
+    for option in self.options:
+      if option['text'] == text:
+        return self.select(option['value'])
+    
+    raise ValueError(
+      f"Option with text '{text}' not found. "
+      f"Available texts: {[opt['text'] for opt in self.options]}"
+    )
+  
+  def deselect(self, value):
+    """
+    Deselect an option (only for multiple selects).
+
+    Args:
+        value: The value of the option to deselect.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+
+    Raises:
+        ValueError: If called on a non-multiple select.
+    """
+    if not self.is_multiple:
+      raise ValueError("Cannot deselect on a single-select dropdown")
+    
+    current = self.fields.get(self.name, [])
+    if not isinstance(current, list):
+      current = [current] if current else []
+    
+    if value in current:
+      current.remove(value)
+      self.fields[self.name] = current[0] if len(current) == 1 else current
+      return self._send_value()
+    
+    return None
+
+
+class TestableRange(TestableControl):
+  """
+  Represents a range input (slider) that can be interacted with in tests.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable range input.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    super().__init__(client, source, "input")
+    
+    # Extract min, max, step from attributes
+    self._min = float(self.my_ft.attrs.get('min', 0))
+    self._max = float(self.my_ft.attrs.get('max', 100))
+    self._step = float(self.my_ft.attrs.get('step', 1))
+  
+  @property
+  def min_value(self):
+    """Get the minimum value of the range."""
+    return self._min
+  
+  @property
+  def max_value(self):
+    """Get the maximum value of the range."""
+    return self._max
+  
+  @property
+  def step(self):
+    """Get the step increment of the range."""
+    return self._step
+  
+  def set(self, value):
+    """
+    Set the range value.
+
+    Args:
+        value: Numeric value to set (will be clamped to min/max).
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    # Clamp value to valid range
+    value = max(self._min, min(self._max, float(value)))
+    
+    # Round to nearest step
+    value = round((value - self._min) / self._step) * self._step + self._min
+    
+    self.fields[self.name] = value
+    return self._send_value()
+  
+  def increase(self):
+    """
+    Increase the range value by one step.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    current = float(self.fields.get(self.name, self._min))
+    return self.set(current + self._step)
+  
+  def decrease(self):
+    """
+    Decrease the range value by one step.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    current = float(self.fields.get(self.name, self._min))
+    return self.set(current - self._step)
+
+
+class TestableRadio(TestableControl):
+  """
+  Represents a radio button input that can be interacted with in tests.
+
+  Note: Radio buttons with the same name form a group where only one
+  can be selected at a time.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable radio button.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    super().__init__(client, source, "input")
+    nb_radio_buttons = len(self.element.find_all("input", type="radio"))
+    assert nb_radio_buttons > 0, "No radio buttons found."
+    assert nb_radio_buttons < 2, "Only one radio button per name is supported."
+    self._radio_value = self.my_ft.attrs.get('value', '')
+  
+  @property
+  def radio_value(self):
+    """Get the value attribute of this radio button."""
+    return self._radio_value
+  
+  @property
+  def is_checked(self):
+    """Check if this radio button is currently selected."""
+    return self.fields.get(self.name) == self._radio_value
+  
+  def select(self):
+    """
+    Select this radio button.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    self.fields[self.name] = self._radio_value
+    return self._send_value()
+
+
+class TestableButton(TestableElement):
+  """
+  Represents a button element that can be clicked in tests.
+
+  Buttons can trigger HTMX requests or form submissions.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable button.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    super().__init__(client, source, "button")
+  
+  @property
+  def text(self):
+    """Get the visible text of the button."""
+    return self.element.get_text(strip=True)
+  
+  def click(self):
+    """
+    Click the button and trigger any associated HTMX request.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    if self._support_htmx():
+      return self._send_htmx_request()
+    return None
+
+
+class TestableDatalist(TestableControl):
+  """
+  Represents an input with datalist (autocomplete/combobox) that can be
+  interacted with in tests.
+
+  This is essentially an input that can show suggestions from a datalist.
+  """
+  
+  def __init__(self, client, source):
+    """
+    Initialize a testable input with datalist.
+
+    Args:
+        client: The MyTestClient instance.
+        source: The source HTML or BeautifulSoup Tag.
+    """
+    super().__init__(client, source, "input")
+    
+    # Find associated datalist
+    list_id = self.my_ft.attrs.get('list')
+    self._datalist_options = []
+    
+    if list_id:
+      # Parse the full HTML to find the datalist
+      soup = BeautifulSoup(self.html_fragment, 'html.parser')
+      datalist = soup.find('datalist', id=list_id)
+      
+      if datalist:
+        for option in datalist.find_all('option'):
+          option_value = option.get('value', option.get_text(strip=True))
+          self._datalist_options.append(option_value)
+  
+  @property
+  def suggestions(self):
+    """
+    Get all available suggestions from the datalist.
+
+    Returns:
+        List of suggestion values.
+    """
+    return self._datalist_options
+  
+  def send(self, value):
+    """
+    Set the input value (can be any value, not restricted to suggestions).
+
+    Args:
+        value: The value to set.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+    """
+    self.fields[self.name] = value
+    return self._send_value()
+  
+  def select_suggestion(self, value):
+    """
+    Select a value from the datalist suggestions.
+
+    Args:
+        value: The suggestion value to select.
+
+    Returns:
+        Response from HTMX request if applicable, None otherwise.
+
+    Raises:
+        ValueError: If the value is not in the suggestions.
+    """
+    if value not in self._datalist_options:
+      raise ValueError(
+        f"Value '{value}' not found in datalist suggestions. "
+        f"Available: {self._datalist_options}"
+      )
+    
+    return self.send(value)
+
+
+# Update the TestableElement factory method
+# This should be added to the MyTestClient._testable_element_factory method
+
+def _testable_element_factory_extended(client, elt):
+  """
+  Extended factory method for creating appropriate Testable* instances.
+
+  This should replace or extend the existing _testable_element_factory method
+  in MyTestClient.
+
+  Args:
+      client: The MyTestClient instance.
+      elt: BeautifulSoup Tag element.
+
+  Returns:
+      Appropriate Testable* instance based on element type.
+  """
+  if elt.name == "input":
+    input_type = elt.get("type", "text").lower()
+    
+    if input_type == "checkbox":
+      return TestableCheckbox(client, elt)
+    elif input_type == "radio":
+      return TestableRadio(client, elt)
+    elif input_type == "range":
+      return TestableRange(client, elt)
+    elif elt.get("list"):  # Input with datalist
+      return TestableDatalist(client, elt)
+    else:
+      return TestableInput(client, elt)
+  
+  elif elt.name == "textarea":
+    return TestableTextarea(client, elt)
+  
+  elif elt.name == "select":
+    return TestableSelect(client, elt)
+  
+  elif elt.name == "button":
+    return TestableButton(client, elt)
+  
+  else:
+    return TestableElement(client, elt, elt.name)
+
 
 #   def get_value(tag):
 #     """Return the current user-facing value of an HTML input-like element."""
@@ -1136,6 +1409,9 @@ class MyTestClient:
         f"Found {len(remaining)} forms (with the specified fields). Expected exactly 1."
       )
   
+  def find_input(self, identifier: str) -> TestableInput:
+    pass
+  
   def get_content(self) -> str:
     """
     Get the raw HTML content of the last opened page.
@@ -1157,8 +1433,38 @@ class MyTestClient:
     return self
   
   def _testable_element_factory(self, elt):
+    """
+    Factory method for creating appropriate Testable* instances.
+
+    Args:
+        elt: BeautifulSoup Tag element.
+
+    Returns:
+        Appropriate Testable* instance based on element type.
+    """
     if elt.name == "input":
+      input_type = elt.get("type", "text").lower()
+      
+      if input_type == "checkbox":
+        return TestableCheckbox(self, elt)
+      elif input_type == "radio":
+        return TestableRadio(self, elt)
+      elif input_type == "range":
+        return TestableRange(self, elt)
+      elif elt.get("list"):  # Input with datalist
+        return TestableDatalist(self, elt)
+      else:
         return TestableInput(self, elt)
+    
+    elif elt.name == "textarea":
+      return TestableTextarea(self, elt)
+    
+    elif elt.name == "select":
+      return TestableSelect(self, elt)
+    
+    elif elt.name == "button":
+      return TestableButton(self, elt)
+    
     else:
       return TestableElement(self, elt, elt.name)
   

tests/auth/test_utils.py

@@ -2,8 +2,10 @@ import pytest
 from fasthtml.fastapp import fast_app
 
 from myfasthtml.auth.utils import create_auth_beforeware
+from myfasthtml.core.utils import quoted_str
 from myfasthtml.test.testclient import MyTestClient
 
+
 def test_non_protected_route():
   app, rt = fast_app()
   user = MyTestClient(app)
@@ -31,3 +33,15 @@ def test_all_routes_are_protected():
   
   user.open("/")
   user.should_see("Sign In")
+
+
+@pytest.mark.parametrize("actual,expected", [
+    ("string", '"string"'),
+    ("string with 'single quotes'", '''"string with 'single quotes'"'''),
+    ('string with "double quotes"', """'string with "double quotes"'"""),
+    ("""string with 'single' and "double" quotes""", '''"string with 'single' and \\"double\\" quotes"'''),
+    (None, "None"),
+    (123, "123"),
+])
+def test_i_can_quote_str(actual, expected):
+  assert quoted_str(actual) == expected

tests/controls/test_helpers.py

@@ -1,13 +1,22 @@
+from dataclasses import dataclass
+from typing import Any
+
 import pytest
 from fasthtml.components import *
 from fasthtml.fastapp import fast_app
 
 from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
 from myfasthtml.core.commands import Command
 from myfasthtml.test.matcher import matches
 from myfasthtml.test.testclient import MyTestClient
 
 
+@dataclass
+class Data:
+  value: Any
+
+
 @pytest.fixture()
 def user():
   test_app, rt = fast_app(default_hdrs=False)
@@ -46,3 +55,37 @@ def test_i_can_mk_button_with_command(user, rt):
   
   user.find_element("button").click()
   user.should_see("this is my new value")
+
+
+class TestingBindings:
+  @pytest.fixture()
+  def data(self):
+    return Data("value")
+  
+  def test_i_can_bind_an_input(self, data):
+    elt = Input(name="input_elt", value="hello")
+    binding = Binding(data, "value")
+    elt = mk.manage_binding(elt, binding)
+    
+    # element is updated
+    assert "hx-post" in elt.attrs
+    assert "hx-vals" in elt.attrs
+    assert "b_id" in elt.attrs["hx-vals"]
+    
+    # binding is also updated
+    assert binding.ft == elt
+    assert binding.ft_name == "input_elt"
+    
+  def test_i_can_bind_none_input(self, data):
+    elt = Label("hello", name="input_elt")
+    binding = Binding(data, "value")
+    elt = mk.manage_binding(elt, binding)
+    
+    # element is updated
+    assert "hx-post" not in elt.attrs
+    assert "hx-get" not in elt.attrs
+    
+    # binding is also updated
+    assert binding.ft == elt
+    assert binding.ft_name == "input_elt"
+    

tests/controls/test_manage_binding.py

@@ -0,0 +1,891 @@
+"""
+Comprehensive binding tests for all bindable FastHTML components.
+
+This test suite covers:
+- Input (text) - already tested
+- Checkbox - already tested
+- Textarea
+- Select (single)
+- Select (multiple)
+- Range (slider)
+- Radio buttons
+- Button
+- Input with Datalist (combobox)
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import pytest
+from fasthtml.components import (
+  Input, Label, Textarea, Select, Option, Datalist
+)
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding, BooleanConverter
+from myfasthtml.core.constants import Routes, ROUTE_ROOT
+from myfasthtml.test.matcher import matches, AttributeForbidden, AnyValue
+from myfasthtml.test.testclient import MyTestClient
+
+
+@dataclass
+class Data:
+  value: Any = "hello world"
+
+
+@dataclass
+class NumericData:
+  value: int = 50
+
+
+@dataclass
+class BoolData:
+  value: bool = True
+
+
+@dataclass
+class ListData:
+  value: list = None
+  
+  def __post_init__(self):
+    if self.value is None:
+      self.value = []
+
+
+@pytest.fixture()
+def user():
+  test_app, rt = fast_app(default_hdrs=False)
+  user = MyTestClient(test_app)
+  return user
+
+
+@pytest.fixture()
+def rt(user):
+  return user.app.route
+
+
+class TestBindingTextarea:
+  """Tests for binding Textarea components."""
+  
+  def test_i_can_bind_textarea(self):
+    data = Data("")
+    check_box = Textarea(name="textarea_name")
+    
+    binding = Binding(data)
+    mk.manage_binding(check_box, binding)
+    
+    # update the content
+    res = binding.update({"textarea_name": "Hello world !"})
+    expected = [Textarea("Hello world !", name="textarea_name", hx_swap_oob="true")]
+    assert matches(res, expected)
+  
+  def test_i_can_bind_textarea_with_label(self, user, rt):
+    """
+    Textarea should bind bidirectionally with data.
+    Value changes should update the label.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("Initial text")
+      textarea_elt = Textarea(name="textarea_name")
+      label_elt = Label()
+      mk.manage_binding(textarea_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return textarea_elt, label_elt
+    
+    user.open("/")
+    user.should_see("Initial text")
+    
+    testable_textarea = user.find_element("textarea")
+    testable_textarea.send("New multiline\ntext content")
+    user.should_see("New multiline\ntext content")
+  
+  def test_textarea_append_works_with_binding(self, user, rt):
+    """
+    Appending text to textarea should trigger binding update.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("Start")
+      textarea_elt = Textarea(name="textarea_name")
+      label_elt = Label()
+      mk.manage_binding(textarea_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return textarea_elt, label_elt
+    
+    user.open("/")
+    user.should_see("Start")
+    
+    testable_textarea = user.find_element("textarea")
+    testable_textarea.append(" + More")
+    user.should_see("Start + More")
+  
+  def test_textarea_clear_works_with_binding(self, user, rt):
+    """
+    Clearing textarea should update binding to empty string.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("Content to clear")
+      textarea_elt = Textarea(name="textarea_name")
+      label_elt = Label()
+      mk.manage_binding(textarea_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return textarea_elt, label_elt
+    
+    user.open("/")
+    user.should_see("Content to clear")
+    
+    testable_textarea = user.find_element("textarea")
+    testable_textarea.clear()
+    user.should_not_see("Content to clear")
+
+
+class TestBindingSelect:
+  """Tests for binding Select components (single selection)."""
+  
+  def test_i_can_bind_select(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name"
+    )
+    
+    binding = Binding(data)
+    updated = mk.manage_binding(select_elt, binding)
+    
+    expected = Select(
+      AttributeForbidden("hx_swap_oob"),
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+    )
+    assert matches(updated, expected)
+  
+  def test_i_can_update_select(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name"
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(select_elt, binding)
+    
+    res = binding.update({"select_name": "option2"})
+    
+    expected = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2", selected="true"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      hx_swap_oob="true"
+    )
+    assert matches(res, [expected])
+  
+  def test_i_can_change_selection(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name"
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(select_elt, binding)
+    
+    binding.update({"select_name": "option2"})
+    res = binding.update({"select_name": "option1"})
+    
+    expected = Select(
+      Option("Option 1", value="option1", selected="true"),
+      Option(AttributeForbidden("selected"), "Option 2", value="option2"),
+      Option(AttributeForbidden("selected"), "Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      hx_swap_oob="true"
+    )
+    assert matches(res, [expected])
+  
+  def test_i_can_bind_select_single(self, user, rt):
+    """
+    Single select should bind with data.
+    Selecting an option should update the label.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("option1")
+      select_elt = Select(
+        Option("Option 1", value="option1"),
+        Option("Option 2", value="option2"),
+        Option("Option 3", value="option3"),
+        name="select_name"
+      )
+      label_elt = Label()
+      mk.manage_binding(select_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return select_elt, label_elt
+    
+    user.open("/")
+    user.should_see("option1")
+    
+    testable_select = user.find_element("select")
+    testable_select.select("option2")
+    user.should_see("option2")
+    
+    testable_select.select("option3")
+    user.should_see("option3")
+  
+  def test_i_can_bind_select_by_text(self, user, rt):
+    """
+    Selecting by visible text should work with binding.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("opt1")
+      select_elt = Select(
+        Option("First Option", value="opt1"),
+        Option("Second Option", value="opt2"),
+        Option("Third Option", value="opt3"),
+        name="select_name"
+      )
+      label_elt = Label()
+      mk.manage_binding(select_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return select_elt, label_elt
+    
+    user.open("/")
+    user.should_see("opt1")
+    
+    testable_select = user.find_element("select")
+    testable_select.select_by_text("Second Option")
+    user.should_see("opt2")
+  
+  def test_select_with_default_selected_option(self, user, rt):
+    """
+    Select with a pre-selected option should initialize correctly.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("option2")
+      select_elt = Select(
+        Option("Option 1", value="option1"),
+        Option("Option 2", value="option2", selected=True),
+        Option("Option 3", value="option3"),
+        name="select_name"
+      )
+      label_elt = Label()
+      mk.manage_binding(select_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return select_elt, label_elt
+    
+    user.open("/")
+    user.should_see("option2")
+
+
+class TestBindingSelectMultiple:
+  """Tests for binding Select components with multiple selection."""
+  
+  def test_i_can_bind_select_multiple(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      multiple=True
+    )
+    
+    binding = Binding(data)
+    updated = mk.manage_binding(select_elt, binding)
+    
+    expected = Select(
+      AttributeForbidden("hx_swap_oob"),
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+    )
+    assert matches(updated, expected)
+  
+  def test_i_can_update_one_selection(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      multiple=True
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(select_elt, binding)
+    
+    res = binding.update({"select_name": "option2"})
+    
+    expected = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2", selected="true"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      hx_swap_oob="true"
+    )
+    assert matches(res, [expected])
+  
+  def test_i_can_update_multiple_selections(self):
+    data = Data("")
+    select_elt = Select(
+      Option("Option 1", value="option1"),
+      Option("Option 2", value="option2"),
+      Option("Option 3", value="option3"),
+      name="select_name",
+      multiple=True
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(select_elt, binding)
+    
+    res = binding.update({"select_name": ["option2", "option3"]})
+    
+    expected = Select(
+      Option(AttributeForbidden("selected"), "Option 1", value="option1"),
+      Option("Option 2", value="option2", selected="true"),
+      Option("Option 3", value="option3", selected="true"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      hx_swap_oob="true"
+    )
+    assert matches(res, [expected])
+  
+  def test_i_can_update_unselect(self):
+    data = Data(["option1", "option2", "option3"])
+    select_elt = Select(
+      Option("Option 1", value="option1", selected="true"),
+      Option("Option 2", value="option2", selected="true"),
+      Option("Option 3", value="option3", selected="true"),
+      name="select_name",
+      multiple=True
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(select_elt, binding)
+    
+    res = binding.update({})
+    
+    expected = Select(
+      Option(AttributeForbidden("selected"), "Option 1", value="option1"),
+      Option(AttributeForbidden("selected"), "Option 2", value="option2"),
+      Option(AttributeForbidden("selected"), "Option 3", value="option3"),
+      name="select_name",
+      id=AnyValue(),
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      hx_swap_oob="true"
+    )
+    assert matches(res, [expected])
+  
+  def test_i_can_bind_select_multiple_with_label(self, user, rt):
+    """
+    Multiple select should bind with list data.
+    Selecting multiple options should update the label.
+    """
+    
+    @rt("/")
+    def index():
+      data = ListData(["option1"])
+      select_elt = Select(
+        Option("Option 1", value="option1"),
+        Option("Option 2", value="option2"),
+        Option("Option 3", value="option3"),
+        name="select_name",
+        multiple=True
+      )
+      label_elt = Label()
+      mk.manage_binding(select_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return select_elt, label_elt
+    
+    user.open("/")
+    user.should_see("['option1']")
+    
+    testable_select = user.find_element("select")
+    testable_select.select("option2")
+    user.should_see("['option1', 'option2']")
+    
+    testable_select.select("option3")
+    user.should_see("['option1', 'option2', 'option3']")
+  
+  def test_i_can_deselect_from_multiple_select(self, user, rt):
+    """
+    Deselecting options from multiple select should update binding.
+    """
+    
+    @rt("/")
+    def index():
+      data = ListData(["option1", "option2"])
+      select_elt = Select(
+        Option("Option 1", value="option1"),
+        Option("Option 2", value="option2"),
+        Option("Option 3", value="option3"),
+        name="select_name",
+        multiple=True
+      )
+      label_elt = Label()
+      mk.manage_binding(select_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return select_elt, label_elt
+    
+    user.open("/")
+    user.should_see("['option1', 'option2']")
+    
+    testable_select = user.find_element("select")
+    testable_select.deselect("option1")
+    user.should_see("option2")
+
+
+class TestBindingRange:
+  """Tests for binding Range (slider) components."""
+  
+  def test_i_can_bind_range(self):
+    data = Data(50)
+    range_elt = Input(
+      type="range",
+      name="range_name",
+      min="0",
+      max="100",
+      value="50"
+    )
+    
+    binding = Binding(data)
+    updated = mk.manage_binding(range_elt, binding)
+    
+    expected = Input(
+      AttributeForbidden("hx_swap_oob"),
+      type="range",
+      name="range_name",
+      min="0",
+      max="100",
+      value=50,
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      id=AnyValue(),
+    )
+    assert matches(updated, expected)
+  
+  def test_i_can_update_range(self):
+    data = Data(50)
+    range_elt = Input(
+      type="range",
+      name="range_name",
+      min="0",
+      max="100",
+      value="50"
+    )
+    
+    binding = Binding(data)
+    mk.manage_binding(range_elt, binding)
+    
+    res = binding.update({"range_name": 25})
+    
+    expected = [Input(
+      type="range",
+      name="range_name",
+      min="0",
+      max="100",
+      value=25,
+      hx_post=f"{ROUTE_ROOT}{Routes.Bindings}",
+      id=AnyValue(),
+      hx_swap_oob="true"
+    )]
+    assert matches(res, expected)
+  
+  def test_i_can_bind_range_with_label(self, user, rt):
+    """
+    Range input should bind with numeric data.
+    Changing the slider should update the label.
+    """
+    
+    @rt("/")
+    def index():
+      data = NumericData(50)
+      range_elt = Input(
+        type="range",
+        name="range_name",
+        min="0",
+        max="100",
+        value="50"
+      )
+      label_elt = Label()
+      mk.manage_binding(range_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return range_elt, label_elt
+    
+    user.open("/")
+    user.should_see("50")
+    
+    testable_range = user.find_element("input[type='range']")
+    testable_range.set(75)
+    user.should_see("75")
+    
+    testable_range.set(25)
+    user.should_see("25")
+  
+  def test_range_increase_decrease(self, user, rt):
+    """
+    Increasing and decreasing range should update binding.
+    """
+    
+    @rt("/")
+    def index():
+      data = NumericData(50)
+      range_elt = Input(
+        type="range",
+        name="range_name",
+        min="0",
+        max="100",
+        step="10",
+        value="50"
+      )
+      label_elt = Label()
+      mk.manage_binding(range_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return range_elt, label_elt
+    
+    user.open("/")
+    user.should_see("50")
+    
+    testable_range = user.find_element("input[type='range']")
+    testable_range.increase()
+    user.should_see("60")
+    
+    testable_range.increase()
+    user.should_see("70")
+    
+    testable_range.decrease()
+    user.should_see("60")
+  
+  def test_range_clamping_to_min_max(self, user, rt):
+    """
+    Range values should be clamped to min/max bounds.
+    """
+    
+    @rt("/")
+    def index():
+      data = NumericData(50)
+      range_elt = Input(
+        type="range",
+        name="range_name",
+        min="0",
+        max="100",
+        value="50"
+      )
+      label_elt = Label()
+      mk.manage_binding(range_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return range_elt, label_elt
+    
+    user.open("/")
+    
+    testable_range = user.find_element("input[type='range']")
+    testable_range.set(150)  # Above max
+    user.should_see("100")
+    
+    testable_range.set(-10)  # Below min
+    user.should_see("0")
+
+
+class TestBindingRadio:
+  """Tests for binding Radio button components."""
+  
+  def test_i_can_bind_radio_buttons(self):
+    data = Data()
+    radio1 = Input(type="radio", name="radio_name", value="option1")
+    radio2 = Input(type="radio", name="radio_name", value="option2")
+    radio3 = Input(type="radio", name="radio_name", value="option3")
+    
+    binding = Binding(data)
+    mk.manage_binding(radio1, binding)
+    mk.manage_binding(radio2, Binding(data))
+    mk.manage_binding(radio3, Binding(data))
+    
+    res = binding.update({"radio_name": "option1"})  # option1 is selected
+    expected = [
+        Input(type="radio", name="radio_name", value="option1", checked="true", hx_swap_oob="true"),
+        Input(AttributeForbidden("checked"), type="radio", name="radio_name", value="option2", hx_swap_oob="true"),
+        Input(AttributeForbidden("checked"), type="radio", name="radio_name", value="option3", hx_swap_oob="true"),
+    ]
+    assert matches(res, expected)
+  
+  def test_i_can_bind_radio_buttons_and_label(self, user, rt):
+    """
+    Radio buttons should bind with data.
+    Selecting a radio should update the label.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data()
+      radio1 = Input(type="radio", name="radio_name", value="option1", checked="true")
+      radio2 = Input(type="radio", name="radio_name", value="option2")
+      radio3 = Input(type="radio", name="radio_name", value="option3")
+      label_elt = Label()
+      
+      mk.manage_binding(radio1, Binding(data))
+      mk.manage_binding(radio2, Binding(data))
+      mk.manage_binding(radio3, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return radio1, radio2, radio3, label_elt
+    
+    user.open("/")
+    
+    # Select second radio
+    testable_radio2 = user.find_element("input[value='option2']")
+    testable_radio2.select()
+    user.should_see("option2")
+    
+    # Select third radio
+    testable_radio3 = user.find_element("input[value='option3']")
+    testable_radio3.select()
+    user.should_see("option3")
+  
+  def test_radio_initial_state(self, user, rt):
+    """
+    Radio buttons should initialize with correct checked state.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("option2")
+      radio1 = Input(type="radio", name="radio_name", value="option1")
+      radio2 = Input(type="radio", name="radio_name", value="option2", checked=True)
+      radio3 = Input(type="radio", name="radio_name", value="option3")
+      label_elt = Label()
+      
+      mk.manage_binding(radio1, Binding(data))
+      mk.manage_binding(radio2, Binding(data))
+      mk.manage_binding(radio3, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return radio1, radio2, radio3, label_elt
+    
+    user.open("/")
+    user.should_see("option2")
+
+
+class TestBindingDatalist:
+  """Tests for binding Input with Datalist (combobox)."""
+  
+  def test_i_can_bind_datalist(self):
+    data = Data(["suggestion2"])
+    datalist = Datalist(
+      Option(value="suggestion1"),
+      id="suggestions"
+    )
+    
+    updated = mk.manage_binding(datalist, Binding(data))
+    expected = Datalist(
+      Option(value="suggestion2"),
+      id="suggestions"
+    )
+    
+    assert matches(updated, expected)
+
+
+class TestBindingEdgeCases:
+  """Tests for edge cases and special scenarios."""
+  
+  def test_multiple_components_bind_to_same_data(self, user, rt):
+    """
+    Multiple different components can bind to the same data object.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("synchronized")
+      
+      input_elt = Input(name="input_name")
+      textarea_elt = Textarea(name="textarea_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(textarea_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, textarea_elt, label_elt
+    
+    user.open("/")
+    user.should_see("synchronized")
+    
+    # Change via input
+    testable_input = user.find_element("input")
+    testable_input.send("changed via input")
+    user.should_see("changed via input")
+    
+    # Change via textarea
+    testable_textarea = user.find_element("textarea")
+    testable_textarea.send("changed via textarea")
+    user.should_see("changed via textarea")
+  
+  def test_component_without_name_attribute(self, user, rt):
+    """
+    Component without name attribute should handle gracefully.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("test")
+      # Input without name - should not crash
+      input_elt = Input()  # No name attribute
+      label_elt = Label()
+      
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    user.should_see("test")
+  
+  def test_binding_with_initial_empty_string(self, user, rt):
+    """
+    Binding should work correctly with empty string initial values.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("")
+      input_elt = Input(name="input_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    
+    testable_input = user.find_element("input")
+    testable_input.send("now has value")
+    user.should_see("now has value")
+  
+  def test_binding_with_special_characters(self, user, rt):
+    """
+    Binding should handle special characters correctly.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("Hello")
+      input_elt = Input(name="input_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    
+    testable_input = user.find_element("input")
+    testable_input.send("Special: <>&\"'")
+    user.should_see("Special: <>&\"'")
+
+
+class TestCheckBox:
+  def test_i_can_bind_checkbox(self):
+    data = Data("")
+    check_box = Input(name="checkbox_name", type="checkbox")
+    
+    binding = Binding(data)
+    mk.manage_binding(check_box, binding)
+    
+    # checkbox is selected
+    res = binding.update({"checkbox_name": "on"})
+    expected = [Input(name="checkbox_name", type="checkbox", checked="true", hx_swap_oob="true")]
+    assert matches(res, expected)
+    
+    # check box is not selected
+    res = binding.update({})
+    expected = [Input(AttributeForbidden("checked"), name="checkbox_name", type="checkbox", hx_swap_oob="true")]
+    assert matches(res, expected)
+  
+  def test_checkbox_initial_state_false(self):
+    data = Data(False)
+    check_box = Input(name="checkbox_name", type="checkbox")
+    
+    binding = Binding(data)
+    updated = mk.manage_binding(check_box, binding)
+    
+    expected = Input(AttributeForbidden("checked"), name="checkbox_name", type="checkbox")
+    assert matches(updated, expected)
+  
+  def test_checkbox_initial_state_true(self):
+    data = Data(True)
+    check_box = Input(name="checkbox_name", type="checkbox")
+    
+    binding = Binding(data)
+    updated = mk.manage_binding(check_box, binding)
+    
+    expected = Input(name="checkbox_name", type="checkbox", checked="true")
+    assert matches(updated, expected)
+  
+  def test_i_can_bind_checkbox_and_label_without_converter(self, user, rt):
+    @rt("/")
+    def index():
+      data = Data(True)
+      input_elt = Input(name="input_name", type="checkbox")
+      label_elt = Label()
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      return input_elt, label_elt
+    
+    user.open("/")
+    user.should_see("True")
+    testable_input = user.find_element("input")
+    
+    testable_input.check()
+    user.should_see("on")
+    
+    testable_input.uncheck()
+    user.should_not_see("on")
+  
+  def test_i_can_bind_checkbox_and_label_with_converter(self, user, rt):
+    @rt("/")
+    def index():
+      data = Data(True)
+      input_elt = Input(name="input_name", type="checkbox")
+      label_elt = Label()
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data, converter=BooleanConverter()))
+      return input_elt, label_elt
+    
+    user.open("/")
+    user.should_see("True")
+    testable_input = user.find_element("input")
+    
+    testable_input.check()
+    user.should_see("True")
+    
+    testable_input.uncheck()
+    user.should_see("False")

tests/core/test_bindings.py

@@ -4,7 +4,13 @@ import pytest
 from fasthtml.components import Label, Input
 from myutils.observable import collect_return_values
 
-from myfasthtml.core.bindings import BindingsManager, Binding
+from myfasthtml.core.bindings import (
+  BindingsManager,
+  Binding,
+  DetectionMode,
+  UpdateMode,
+  BooleanConverter
+)
 
 
 @dataclass
@@ -39,12 +45,15 @@ def test_i_can_register_a_binding_with_default_attr(data):
 
 
 def test_i_can_retrieve_a_registered_binding(data):
-  binding = Binding(data)
+  elt = Label("hello", id="label_id")
+  binding = Binding(data).bind_ft(elt, name="label_name")
+  
   assert BindingsManager.get_binding(binding.id) is binding
 
 
 def test_i_can_reset_bindings(data):
-  Binding(data)
+  elt = Label("hello", id="label_id")
+  Binding(data).bind_ft(elt, name="label_name")
   assert len(BindingsManager.bindings) != 0
   
   BindingsManager.reset()
@@ -53,7 +62,7 @@ def test_i_can_reset_bindings(data):
 
 def test_i_can_bind_an_element_to_a_binding(data):
   elt = Label("hello", id="label_id")
-  Binding(data, ft=elt)
+  Binding(data).bind_ft(elt, name="label_name")
   
   data.value = "new value"
   
@@ -63,9 +72,9 @@ def test_i_can_bind_an_element_to_a_binding(data):
 
 
 def test_i_can_bind_an_element_attr_to_a_binding(data):
-  elt = Input(value="somme value", id="input_id")
+  elt = Input(value="some value", id="input_id")
   
-  Binding(data, ft=elt, ft_attr="value")
+  Binding(data).bind_ft(elt, name="input_name", attr="value")
   
   data.value = "new value"
   
@@ -78,13 +87,13 @@ def test_bound_element_has_an_id():
   elt = Label("hello")
   assert elt.attrs.get("id", None) is None
   
-  Binding(Data(), ft=elt)
+  Binding(Data()).bind_ft(elt, name="label_name")
   assert elt.attrs.get("id", None) is not None
 
 
 def test_i_can_collect_updates_values(data):
   elt = Label("hello")
-  Binding(data, ft=elt)
+  Binding(data).bind_ft(elt, name="label_name")
   
   data.value = "new value"
   collected = collect_return_values(data)
@@ -94,3 +103,281 @@ def test_i_can_collect_updates_values(data):
   data.value = "another value"
   collected = collect_return_values(data)
   assert collected == [elt]
+
+
+def test_i_can_react_to_value_change(data):
+  elt = Input(name="input_elt", value="hello")
+  binding = Binding(data).bind_ft(elt, name="input_elt", attr="value")
+  
+  res = binding.update({"input_elt": "new value"})
+  
+  assert len(res) == 1
+
+
+def test_i_do_not_react_to_other_value_change(data):
+  elt = Input(name="input_elt", value="hello")
+  binding = Binding(data).bind_ft(elt, name="input_elt", attr="value")
+  
+  res = binding.update({"other_input_elt": "new value"})
+  
+  assert res is None
+
+
+def test_i_can_react_to_attr_presence(data):
+  elt = Input(name="input_elt", type="checkbox")
+  binding = Binding(data).bind_ft(
+    elt,
+    name="input_elt",
+    attr="checked",
+    detection_mode=DetectionMode.AttributePresence
+  )
+  
+  res = binding.update({"checked": "true"})
+  
+  assert len(res) == 1
+
+
+def test_i_can_react_to_attr_non_presence(data):
+  elt = Input(name="input_elt", type="checkbox")
+  binding = Binding(data).bind_ft(
+    elt,
+    name="input_elt",
+    attr="checked",
+    detection_mode=DetectionMode.AttributePresence
+  )
+  
+  res = binding.update({})
+  
+  assert len(res) == 1
+
+
+def test_i_can_create_a_binding_without_activation(data):
+  """
+  A binding created without calling bind_ft should not be active.
+  """
+  binding = Binding(data, "value")
+  
+  assert binding._is_active is False
+  assert binding.ft is None
+  assert binding.ft_name is None
+  assert binding.ft_attr is None
+  assert BindingsManager.get_binding(binding.id) is None
+
+
+def test_i_can_activate_binding_via_bind_ft(data):
+  """
+  Calling bind_ft should automatically activate the binding.
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value")
+  
+  binding.bind_ft(elt, name="label_name")
+  
+  assert binding._is_active is True
+  assert binding.ft is elt
+  assert binding.ft_name == "label_name"
+  assert BindingsManager.get_binding(binding.id) is binding
+
+
+def test_i_cannot_notify_when_not_active(data):
+  """
+  A non-active binding should not update the UI when data changes.
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value")
+  binding.ft = elt
+  binding.ft_name = "label_name"
+  
+  # Change data without activating the binding
+  result = binding.notify("old", "new")
+  
+  assert result is None
+  assert elt.children[0] == "hello"  # Should not have changed
+
+
+def test_i_can_deactivate_a_binding(data):
+  """
+  Deactivating a binding should clean up observers and unregister it.
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value").bind_ft(elt, name="label_name")
+  
+  assert binding._is_active is True
+  assert BindingsManager.get_binding(binding.id) is binding
+  
+  binding.deactivate()
+  
+  assert binding._is_active is False
+  assert BindingsManager.get_binding(binding.id) is None
+
+
+def test_i_can_reactivate_a_binding(data):
+  """
+  After deactivation, a binding can be reactivated by calling bind_ft again.
+  """
+  elt1 = Label("hello", id="label_id_1")
+  binding = Binding(data, "value").bind_ft(elt1, name="label_name_1")
+  
+  binding.deactivate()
+  assert binding._is_active is False
+  
+  elt2 = Label("world", id="label_id_2")
+  binding.bind_ft(elt2, name="label_name_2")
+  
+  assert binding._is_active is True
+  assert binding.ft is elt2
+  assert binding.ft_name == "label_name_2"
+
+
+def test_bind_ft_deactivates_before_reconfiguring(data):
+  """
+  Calling bind_ft on an active binding should deactivate it first,
+  then reconfigure and reactivate.
+  """
+  elt1 = Label("hello", id="label_id_1")
+  elt2 = Label("world", id="label_id_2")
+  
+  binding = Binding(data, "value").bind_ft(elt1, name="label_name_1")
+  
+  # Change data to verify old binding works
+  data.value = "updated"
+  assert elt1.children[0] == "updated"
+  
+  # Reconfigure with new element
+  binding.bind_ft(elt2, name="label_name_2")
+  
+  # Change data again
+  data.value = "final"
+  
+  # Old element should not update
+  assert elt1.children[0] == "updated"
+  
+  # New element should update
+  assert elt2.children[0] == "final"
+
+
+def test_deactivate_can_be_called_multiple_times(data):
+  """
+  Calling deactivate multiple times should be safe (idempotent).
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value").bind_ft(elt, name="label_name")
+  
+  binding.deactivate()
+  binding.deactivate()  # Should not raise an error
+  binding.deactivate()  # Should not raise an error
+  
+  assert binding._is_active is False
+
+
+def test_i_cannot_activate_without_configuration(data):
+  """
+  Calling activate directly without proper configuration should raise ValueError.
+  """
+  binding = Binding(data, "value")
+  
+  with pytest.raises(ValueError, match="ft element is required"):
+    binding.activate()
+
+
+def test_activation_validates_strategies(data):
+  """
+  Activation should fail if detection/update strategies are not initialized.
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value")
+  binding.ft = elt
+  binding.ft_name = "label_name"
+  
+  with pytest.raises(ValueError, match="detection strategy not initialized"):
+    binding.activate()
+
+
+def test_i_can_chain_bind_ft_calls(data):
+  """
+  bind_ft should return self for method chaining.
+  """
+  elt = Label("hello", id="label_id")
+  
+  binding = Binding(data, "value").bind_ft(elt, name="label_name")
+  
+  assert isinstance(binding, Binding)
+  assert binding._is_active is True
+
+
+def test_bind_ft_updates_optional_parameters(data):
+  """
+  bind_ft should update optional parameters if provided.
+  """
+  elt = Input(name="input_elt", type="checkbox")
+  
+  binding = Binding(data, "value")
+  
+  binding.bind_ft(
+    elt,
+    name="input_elt",
+    attr="checked",
+    data_converter=BooleanConverter(),
+    detection_mode=DetectionMode.AttributePresence,
+    update_mode=UpdateMode.AttributePresence
+  )
+  
+  assert binding.detection_mode == DetectionMode.AttributePresence
+  assert binding.update_mode == UpdateMode.AttributePresence
+  assert isinstance(binding.data_converter, BooleanConverter)
+
+
+def test_deactivated_binding_does_not_update_on_data_change(data):
+  """
+  After deactivation, changes to data should not update the UI element.
+  """
+  elt = Label("hello", id="label_id")
+  binding = Binding(data, "value").bind_ft(elt, name="label_name")
+  
+  # Verify it works when active
+  data.value = "first update"
+  assert elt.children[0] == "first update"
+  
+  # Deactivate
+  binding.deactivate()
+  
+  # Change data - element should NOT update
+  data.value = "second update"
+  assert elt.children[0] == "first update"
+
+
+def test_multiple_bindings_can_coexist(data):
+  """
+  Multiple bindings can be created and managed independently.
+  """
+  elt1 = Label("hello", id="label_id_1")
+  elt2 = Input(value="world", id="input_id_2")
+  
+  binding1 = Binding(data, "value").bind_ft(elt1, name="label_name")
+  binding2 = Binding(data, "value").bind_ft(elt2, name="input_name", attr="value")
+  
+  assert len(BindingsManager.bindings) == 2
+  assert binding1._is_active is True
+  assert binding2._is_active is True
+  
+  # Change data - both should update
+  data.value = "updated"
+  assert elt1.children[0] == "updated"
+  assert elt2.attrs["value"] == "updated"
+  
+  # Deactivate one
+  binding1.deactivate()
+  assert len(BindingsManager.bindings) == 1
+  
+  # Change data - only binding2 should update
+  data.value = "final"
+  assert elt1.children[0] == "updated"  # Not changed
+  assert elt2.attrs["value"] == "final"  # Changed
+
+
+def test_i_cannot_bind_when_htmx_post_already_set(data):
+  elt = Input(name="input_elt", hx_post="/some/url")
+  binding = Binding(data, "value")
+  
+  with pytest.raises(ValueError, match="htmx post already set on input"):
+    binding.bind_ft(elt, name="label_name")

tests/core/test_commands.py

@@ -1,6 +1,18 @@
+from dataclasses import dataclass
+from typing import Any
+
 import pytest
+from fasthtml.components import Button
+from myutils.observable import make_observable, bind
 
 from myfasthtml.core.commands import Command, CommandsManager
+from myfasthtml.core.constants import ROUTE_ROOT, Routes
+from myfasthtml.test.matcher import matches
+
+
+@dataclass
+class Data:
+  value: Any
 
 
 def callback():
@@ -23,3 +35,61 @@ def test_i_can_create_a_command_with_no_params():
 def test_command_are_registered():
   command = Command('test', 'Command description', callback)
   assert CommandsManager.commands.get(str(command.id)) is command
+
+
+def test_i_can_bind_a_command_to_an_element():
+  command = Command('test', 'Command description', callback)
+  elt = Button()
+  updated = command.bind_ft(elt)
+  
+  expected = Button(hx_post=f"{ROUTE_ROOT}{Routes.Commands}")
+  
+  assert matches(updated, expected)
+
+
+def test_i_can_suppress_swapping_with_target_attr():
+  command = Command('test', 'Command description', callback).htmx(target=None)
+  elt = Button()
+  updated = command.bind_ft(elt)
+  
+  expected = Button(hx_post=f"{ROUTE_ROOT}{Routes.Commands}", hx_swap="none")
+  
+  assert matches(updated, expected)
+
+
+def test_i_can_bind_a_command_to_an_observable():
+  data = Data("hello")
+  
+  def on_data_change(old, new):
+    return old, new
+  
+  def another_callback():
+    data.value = "new value"
+    return "another callback result"
+  
+  make_observable(data)
+  bind(data, "value", on_data_change)
+  command = Command('test', 'Command description', another_callback).bind(data)
+  
+  res = command.execute()
+  
+  assert res == ["another callback result", ("hello", "new value")]
+
+
+def test_i_can_bind_a_command_to_an_observable_2():
+  data = Data("hello")
+  
+  def on_data_change(old, new):
+    return old, new
+  
+  def another_callback():
+    data.value = "new value"
+    return ["another 1", "another 2"]
+  
+  make_observable(data)
+  bind(data, "value", on_data_change)
+  command = Command('test', 'Command description', another_callback).bind(data)
+  
+  res = command.execute()
+  
+  assert res == ["another 1", "another 2", ("hello", "new value")]

tests/test_integration.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Any
 
 import pytest
 from fasthtml.components import Input, Label
@@ -16,7 +17,7 @@ def new_value(value):
 
 @dataclass
 class Data:
-  value: str
+  value: Any
 
 
 @pytest.fixture()
@@ -62,13 +63,13 @@ class TestingCommand:
 
 
 class TestingBindings:
-  def test_i_can_bind_elements(self, user, rt):
+  def test_i_can_bind_input(self, user, rt):
     @rt("/")
     def index():
       data = Data("hello world")
       input_elt = Input(name="input_name")
       label_elt = Label()
-      mk.manage_binding(input_elt, Binding(data, ft_attr="value"))
+      mk.manage_binding(input_elt, Binding(data))
       mk.manage_binding(label_elt, Binding(data))
       return input_elt, label_elt
     

tests/testclient/test_matches.py

@@ -3,7 +3,7 @@ from fastcore.basics import NotStr
 from fasthtml.components import *
 
 from myfasthtml.test.matcher import matches, StartsWith, Contains, DoesNotContain, Empty, DoNotCheck, ErrorOutput, \
-  ErrorComparisonOutput
+  ErrorComparisonOutput, AttributeForbidden, AnyValue
 from myfasthtml.test.testclient import MyFT
 
 
@@ -17,12 +17,14 @@ from myfasthtml.test.testclient import MyFT
     (Div(attr1="valueXXX", attr2="value"), Div(attr1=StartsWith("value"))),
     (Div(attr1="before value after", attr2="value"), Div(attr1=Contains("value"))),
     (Div(attr1="before after", attr2="value"), Div(attr1=DoesNotContain("value"))),
+    (Div(attr1="value"), Div(attr1=AnyValue())),
     (None, DoNotCheck()),
     (123, DoNotCheck()),
     (Div(), DoNotCheck()),
     ([Div(), Span()], DoNotCheck()),
     (NotStr("123456"), NotStr("123")),  # for NotStr, only the beginning is checked
     (Div(), Div(Empty())),
+    (Div(attr1="value1"), Div(AttributeForbidden("attr2"))),
     (Div(123), Div(123)),
     (Div(Span(123)), Div(Span(123))),
     (Div(Span(123)), Div(DoNotCheck())),
@@ -48,10 +50,12 @@ def test_i_can_match(actual, expected):
     (Div(attr1="value1"), Div(attr1=StartsWith("value2")), "The condition 'StartsWith(value2)' is not satisfied"),
     (Div(attr1="value1"), Div(attr1=Contains("value2")), "The condition 'Contains(value2)' is not satisfied"),
     (Div(attr1="value1 value2"), Div(attr1=DoesNotContain("value2")), "The condition 'DoesNotContain(value2)'"),
+    (Div(attr1=None), Div(attr1=AnyValue()), "'attr1' is not found in Actual"),
+    (Div(), Div(attr1=AnyValue()), "'attr1' is not found in Actual"),
     (NotStr("456"), NotStr("123"), "Notstr values are different"),
-    (Div(attr="value"), Div(Empty()), "Actual is not empty"),
-    (Div(120), Div(Empty()), "Actual is not empty"),
-    (Div(Span()), Div(Empty()), "Actual is not empty"),
+    (Div(attr="value"), Div(Empty()), "The condition 'Empty()' is not satisfied"),
+    (Div(120), Div(Empty()), "The condition 'Empty()' is not satisfied"),
+    (Div(Span()), Div(Empty()), "The condition 'Empty()' is not satisfied"),
     (Div(), Div(Span()), "Actual is lesser than expected"),
     (Div(), Div(123), "Actual is lesser than expected"),
     (Div(Span()), Div(Div()), "The elements are different"),
@@ -59,6 +63,7 @@ def test_i_can_match(actual, expected):
     (Div(123), Div(456), "The values are different"),
     (Div(Span(), Span()), Div(Span(), Div()), "The elements are different"),
     (Div(Span(Div())), Div(Span(Span())), "The elements are different"),
+    (Div(attr1="value1"), Div(AttributeForbidden("attr1")), "condition 'AttributeForbidden(attr1)' is not satisfied"),
 ])
 def test_i_can_detect_errors(actual, expected, error_message):
   with pytest.raises(AssertionError) as exc_info:
@@ -174,6 +179,7 @@ def test_i_can_output_error_when_predicate():
 
 
 def test_i_can_output_error_when_predicate_wrong_value():
+  """I can display error when the condition predicate is not satisfied."""
   elt = "before after"
   expected = Contains("value")
   path = ""
@@ -184,6 +190,7 @@ def test_i_can_output_error_when_predicate_wrong_value():
 
 
 def test_i_can_output_error_child_element():
+  """I can display error when the element has children"""
   elt = Div(P(id="p_id"), Div(id="child_1"), Div(id="child_2"), attr1="value1")
   expected = elt
   path = ""
@@ -196,6 +203,19 @@ def test_i_can_output_error_child_element():
                                  ')',
                                  ]
 
+def test_i_can_output_error_child_element_text():
+  """I can display error when the children is not a FT"""
+  elt = Div("Hello world", Div(id="child_1"), Div(id="child_2"), attr1="value1")
+  expected = elt
+  path = ""
+  error_output = ErrorOutput(path, elt, expected)
+  error_output.compute()
+  assert error_output.output == ['(div "attr1"="value1"',
+                                 '  "Hello world"',
+                                 '  (div "id"="child_1")',
+                                 '  (div "id"="child_2")',
+                                 ')',
+                                 ]
 
 def test_i_can_output_error_child_element_indicating_sub_children():
   elt = Div(P(id="p_id"), Div(Div(id="child_2"), id="child_1"), attr1="value1")

tests/testclient/test_mytestclient.py

@@ -481,4 +481,3 @@ class TestMyTestClientFindForm:
     
     error_message = str(exc_info.value)
     assert "Found 2 forms (with the specified fields). Expected exactly 1." in error_message
-

tests/testclient/test_teastable_radio.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+
+import pytest
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.test.testclient import MyTestClient, TestableRadio
+
+
+@dataclass
+class Data:
+  value: str = "hello world"
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def test_client(test_app):
+  return MyTestClient(test_app)
+
+
+def test_i_can_read_not_selected_radio(test_client):
+  html = '''<input type="radio" name="radio_name" value="option1" />'''
+  
+  input_elt = TestableRadio(test_client, html)
+  
+  assert input_elt.name == "radio_name"
+  assert input_elt.value is None
+
+
+def test_i_can_read_selected_radio(test_client):
+  html = '''<input type="radio" name="radio_name" value="option1" checked="true"/>'''
+  
+  input_elt = TestableRadio(test_client, html)
+  
+  assert input_elt.name == "radio_name"
+  assert input_elt.value == "option1"
+
+
+def test_i_cannot_read_radio_with_multiple_values(test_client):
+  html = '''
+  <input type="radio" name="radio_name" value="option1" checked="true" />
+  <input type="radio" name="radio_name" value="option2" />
+  '''
+  
+  with pytest.raises(AssertionError) as exc_info:
+    TestableRadio(test_client, html)
+  
+  assert "Only one radio button per name is supported" in str(exc_info.value)
+
+
+def test_i_cannot_read_radio_when_no_radio_button(test_client):
+  html = '''
+  <input type="text" name="radio_name" value="option1" checked="true" /> '''
+  
+  with pytest.raises(AssertionError) as exc_info:
+    TestableRadio(test_client, html)
+  
+  assert "No radio buttons found" in str(exc_info.value)
+
+
+def test_i_can_read_input_with_label(test_client):
+  html = '''<label for="uid">John Doe</label><input id="uid" type="radio" name="username" value="john_doe" />'''
+  
+  input_elt = TestableRadio(test_client, html)
+  assert input_elt.fields_mapping == {"John Doe": "username"}
+  assert input_elt.name == "username"
+  assert input_elt.value is None
+
+
+def test_i_can_send_values(test_client, rt):
+  html = '''<input type="text" name="username" type="radio" value="john_doe" hx_post="/submit"/>'''
+  
+  @rt('/submit')
+  def post(username: str):
+    return f"Input received {username=}"
+  
+  input_elt = TestableRadio(test_client, html)
+  input_elt.select()
+  
+  assert test_client.get_content() == "Input received username='john_doe'"

tests/testclient/test_testable.py

@@ -0,0 +1,165 @@
+"""
+Comprehensive binding tests for all bindable FastHTML components.
+
+This test suite covers:
+- Input (text) - already tested
+- Checkbox - already tested
+- Textarea
+- Select (single)
+- Select (multiple)
+- Range (slider)
+- Radio buttons
+- Button
+- Input with Datalist (combobox)
+"""
+
+from dataclasses import dataclass
+
+import pytest
+from fasthtml.components import (
+  Input, Label, Textarea
+)
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.controls.helpers import mk
+from myfasthtml.core.bindings import Binding
+from myfasthtml.test.testclient import MyTestClient
+
+
+@dataclass
+class Data:
+  value: str = "hello world"
+
+
+@dataclass
+class NumericData:
+  value: int = 50
+
+
+@dataclass
+class BoolData:
+  value: bool = True
+
+
+@dataclass
+class ListData:
+  value: list = None
+  
+  def __post_init__(self):
+    if self.value is None:
+      self.value = []
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def user(test_app):
+  return MyTestClient(test_app)
+
+
+class TestBindingEdgeCases:
+  """Tests for edge cases and special scenarios."""
+  
+  def test_multiple_components_bind_to_same_data(self, user, rt):
+    """
+    Multiple different components can bind to the same data object.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("synchronized")
+      
+      input_elt = Input(name="input_name")
+      textarea_elt = Textarea(name="textarea_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(textarea_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, textarea_elt, label_elt
+    
+    user.open("/")
+    user.should_see("synchronized")
+    
+    # Change via input
+    testable_input = user.find_element("input")
+    testable_input.send("changed via input")
+    user.should_see("changed via input")
+    
+    # Change via textarea
+    testable_textarea = user.find_element("textarea")
+    testable_textarea.send("changed via textarea")
+    user.should_see("changed via textarea")
+  
+  def test_component_without_name_attribute(self, user, rt):
+    """
+    Component without name attribute should handle gracefully.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("test")
+      # Input without name - should not crash
+      input_elt = Input()  # No name attribute
+      label_elt = Label()
+      
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    user.should_see("test")
+  
+  def test_binding_with_initial_empty_string(self, user, rt):
+    """
+    Binding should work correctly with empty string initial values.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("")
+      input_elt = Input(name="input_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    
+    testable_input = user.find_element("input")
+    testable_input.send("now has value")
+    user.should_see("now has value")
+  
+  def test_binding_with_special_characters(self, user, rt):
+    """
+    Binding should handle special characters correctly.
+    """
+    
+    @rt("/")
+    def index():
+      data = Data("Hello")
+      input_elt = Input(name="input_name")
+      label_elt = Label()
+      
+      mk.manage_binding(input_elt, Binding(data))
+      mk.manage_binding(label_elt, Binding(data))
+      
+      return input_elt, label_elt
+    
+    user.open("/")
+    
+    testable_input = user.find_element("input")
+    testable_input.send("Special: <>&\"'")
+    user.should_see("Special: <>&\"'")

tests/testclient/test_testable_checkbox.py

@@ -44,7 +44,7 @@ def test_i_can_check_checkbox(test_client, rt):
   html = '''<input type="checkbox" name="male" hx_post="/submit"/>'''
   
   @rt('/submit')
-  def post(male: bool):
+  def post(male: bool=None):
     return f"Checkbox received {male=}"
   
   input_elt = TestableCheckbox(test_client, html)
@@ -53,7 +53,7 @@ def test_i_can_check_checkbox(test_client, rt):
   assert test_client.get_content() == "Checkbox received male=True"
 
   input_elt.uncheck()
-  assert test_client.get_content() == "Checkbox received male=False"
+  assert test_client.get_content() == "Checkbox received male=None"
 
   input_elt.toggle()
   assert test_client.get_content() == "Checkbox received male=True"

tests/testclient/test_testable_form.py

@@ -268,8 +268,7 @@ class TestableFormUpdateFieldValues:
         '''
     form = TestableForm(mock_client, html)
     
-    assert "size" not in form.fields, \
-      f"Expected 'size' not in fields, got {form.fields}"
+    assert form.fields == {"size": None}, f"Expected 'size' not in fields, got {form.fields}"
   
   def test_i_can_handle_number_input_with_integer(self, mock_client):
     """

tests/testclient/test_testable_input.py

@@ -49,3 +49,10 @@ def test_i_can_send_values(test_client, rt):
   input_elt.send("another name")
   
   assert test_client.get_content() == "Input received username='another name'"
+
+
+def i_can_find_input_by_name(test_client):
+  html = '''<label for="uid">Username</label><input id="uid" name="username" value="john_doe" />'''
+  
+  element = test_client.find_input("Username")
+  assert False

tests/testclient/test_testable_range.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+import pytest
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.test.testclient import MyTestClient, TestableRange
+
+
+@dataclass
+class Data:
+  value: str = "hello world"
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def test_client(test_app):
+  return MyTestClient(test_app)
+
+
+def test_i_can_read_range(test_client):
+  html = '''<input type="range" name="range_name" min="0" max="100" step="10" value="50" />'''
+  
+  input_elt = TestableRange(test_client, html)
+  
+  assert input_elt.name == "range_name"
+  assert input_elt.value == 50
+  assert input_elt.min_value == 0
+  assert input_elt.max_value == 100
+  assert input_elt.step == 10
+
+
+@pytest.mark.parametrize("value, expected", [
+    (30, 30),
+    (24, 20),  # step 10
+    (-10, 0),  # min 0
+    (110, 100),  # max 100
+])
+def test_i_can_set_value(test_client, value, expected):
+  html = '''<input type="range" name="range_name" min="0" max="100" step="10" value="50" />'''
+  
+  input_elt = TestableRange(test_client, html)
+  
+  input_elt.set(value)
+  assert input_elt.value == expected
+
+
+def test_i_can_increase_value(test_client):
+  html = '''<input type="range" name="range_name" min="0" max="100" step="10" value="50" />'''
+  
+  input_elt = TestableRange(test_client, html)
+  
+  input_elt.increase()
+  assert input_elt.value == 60
+
+
+def test_i_can_decrease_value(test_client):
+  html = '''<input type="range" name="range_name" min="0" max="100" step="10" value="50" />'''
+  
+  input_elt = TestableRange(test_client, html)
+  
+  input_elt.decrease()
+  assert input_elt.value == 40

tests/testclient/test_testable_select.py

@@ -0,0 +1,63 @@
+import pytest
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.test.testclient import TestableSelect, MyTestClient
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def test_client(test_app):
+  return MyTestClient(test_app)
+
+
+def test_i_can_read_select(test_client):
+  html = '''<select name="select_name">
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  assert select_elt.name == "select_name"
+  assert select_elt.value == "option1"  # if no selected found, the first option is selected by default
+  assert select_elt.options == [{'text': 'Option 1', 'value': 'option1'},
+                                {'text': 'Option 2', 'value': 'option2'},
+                                {'text': 'Option 3', 'value': 'option3'}]
+  assert select_elt.select_fields == {'select_name': [{'text': 'Option 1', 'value': 'option1'},
+                                                      {'text': 'Option 2', 'value': 'option2'},
+                                                      {'text': 'Option 3', 'value': 'option3'}]}
+  assert select_elt.is_multiple is False
+
+
+def test_i_can_select_option(test_client):
+  html = '''<select name="select_name">
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.select("option2")
+  assert select_elt.value == "option2"
+
+
+def test_i_can_select_by_text(test_client):
+  html = '''<select name="select_name">
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.select_by_text("Option 3")
+  assert select_elt.value == "option3"

tests/testclient/test_testable_select_multiple.py

@@ -0,0 +1,107 @@
+import pytest
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.test.testclient import TestableSelect, MyTestClient
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def test_client(test_app):
+  return MyTestClient(test_app)
+
+
+def test_i_can_read_select(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  assert select_elt.name == "select_name"
+  assert select_elt.value == []
+  assert select_elt.options == [{'text': 'Option 1', 'value': 'option1'},
+                                {'text': 'Option 2', 'value': 'option2'},
+                                {'text': 'Option 3', 'value': 'option3'}]
+  assert select_elt.select_fields == {'select_name': [{'text': 'Option 1', 'value': 'option1'},
+                                                      {'text': 'Option 2', 'value': 'option2'},
+                                                      {'text': 'Option 3', 'value': 'option3'}]}
+  assert select_elt.is_multiple is True
+
+
+def test_i_can_read_select_with_multiple_selected_values(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1" selected>Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3" selected>Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  assert select_elt.name == "select_name"
+  assert select_elt.value == ["option1", "option3"]
+  assert select_elt.is_multiple is True
+
+
+def test_i_can_select_option(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.select("option2")
+  assert select_elt.value == "option2"
+
+
+def test_i_can_select_multiple_options(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.select("option2")
+  select_elt.select("option3")
+  assert select_elt.value == ["option2", "option3"]
+
+
+def test_i_can_select_by_text(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1">Option 1</option>
+  <option value="option2">Option 2</option>
+  <option value="option3">Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.select_by_text("Option 3")
+  assert select_elt.value == "option3"
+
+
+def test_i_can_deselect(test_client):
+  html = '''<select name="select_name" multiple>
+  <option value="option1" selected>Option 1</option>
+  <option value="option2" selected>Option 2</option>
+  <option value="option3" selected>Option 3</option>
+  </select>
+  '''
+  select_elt = TestableSelect(test_client, html)
+  select_elt.deselect("option3")
+  assert select_elt.value == ["option1", "option2"]
+  
+  select_elt.deselect("option2")
+  assert select_elt.value == "option1"
+  
+  select_elt.deselect("option1")
+  assert select_elt.value == []

tests/testclient/test_testable_textarea.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+import pytest
+from fasthtml.fastapp import fast_app
+
+from myfasthtml.test.testclient import MyTestClient, TestableTextarea
+
+
+@dataclass
+class Data:
+  value: str = "hello world"
+
+
+@pytest.fixture
+def test_app():
+  test_app, rt = fast_app(default_hdrs=False)
+  return test_app
+
+
+@pytest.fixture
+def rt(test_app):
+  return test_app.route
+
+
+@pytest.fixture
+def test_client(test_app):
+  return MyTestClient(test_app)
+
+
+def test_i_can_read_input(test_client):
+  html = '''<textarea name="textarea_name">Lorem ipsum</textarea>'''
+  
+  input_elt = TestableTextarea(test_client, html)
+  
+  assert input_elt.name == "textarea_name"
+  assert input_elt.value == "Lorem ipsum"