textual-wtf 0.8.0__tar.gz → 0.8.2__tar.gz

textual_wtf-0.8.2/.github/workflows/pypi.yaml

@@ -0,0 +1,76 @@
+name: Publish to PyPI and TestPyPI
+
+on: push
+
+jobs:
+
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.x"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v5
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+      name: >-
+        Publish Python 🐍 distribution 📦 to PyPI
+      if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
+      needs:
+      - build
+      runs-on: ubuntu-latest
+      environment:
+        name: pypi
+        url: https://pypi.org/p/textual-wtf # Replace <package-name> with your PyPI project name
+      permissions:
+        id-token: write  # IMPORTANT: mandatory for trusted publishing
+      steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v6
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-to-testpypi:
+    name: Publish Python 🐍 distribution 📦 to TestPyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/<package-name>
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v6
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/

textual_wtf-0.8.2/CHANGELOG-v0.9-dev1.md

@@ -0,0 +1,188 @@
+# textual-wtf v0.9-dev1 - Changelog
+
+## Major Architectural Changes
+
+### 1. Callable BoundFields (WTForms-style API)
+
+**File: `bound_fields.py`**
+
+- Added `__call__()` method to BoundField class
+  - Returns widget configured with keyword arguments
+  - Tracks field rendering to prevent duplicates
+  - Example: `form.name(placeholder="Enter name", disabled=True)`
+  
+- Updated `create_widget()` method
+  - Now accepts `**kwargs` for runtime configuration
+  - Merges runtime kwargs with field's widget_kwargs
+  - Syncs initial value to widget on creation
+
+**File: `fields.py`**
+
+- Updated `Field.create_widget()` method
+  - Added optional `widget_kwargs` parameter
+  - Merges base configuration with runtime overrides
+
+### 2. FormLayout Architecture
+
+**File: `layouts.py` (NEW)**
+
+Created new layout system with two classes:
+
+**FormLayout (base class)**
+- Inherits from `VerticalScroll`
+- Tracks rendered fields via `_rendered_fields` set
+- Provides `_track_field_render()` to prevent duplicate field rendering
+- Abstract `compose_form()` method for subclasses to implement
+- Delegates to form for data operations (get_data, set_data, validate)
+
+**DefaultFormLayout**
+- Implements default vertical form layout
+- Replicates previous RenderedForm behavior
+- Renders: title → subform titles → fields with labels → buttons
+- Handles submit/cancel button events
+- Posts Form.Submitted and Form.Cancelled messages
+
+### 3. Form Class Updates
+
+**File: `forms.py`**
+
+**Removed:**
+- `RenderedForm` class (replaced by FormLayout system)
+- Unused imports (on, Vertical, Center, Horizontal, VerticalScroll, Button, Static, Label)
+
+**Modified BaseForm:**
+- Added `layout_class` class attribute (defaults to DefaultFormLayout)
+- Updated `__init__()`:
+  - Added `layout_class` parameter (overrides class-level default)
+  - Removed `render_type` parameter
+  - Layout selection logic: instance param → class attribute → DefaultFormLayout
+  
+- Updated `render()` method:
+  - Creates layout instance using `self._layout_class`
+  - Sets `self._current_layout` for field rendering tracking
+  - Returns layout instance (not RenderedForm)
+
+**Modified Form:**
+- Updated `Submitted` and `Cancelled` message classes:
+  - Accept `layout` parameter instead of `r_form`
+  - Store as `self.layout`
+  - Provide `self.form` for backward compatibility
+
+### 4. Public API Updates
+
+**File: `__init__.py`**
+
+Added exports:
+- `FormLayout`
+- `DefaultFormLayout`
+
+Fixed typo in `__all__` (was `"__version__,"` now `"__version__"`)
+
+## Benefits of These Changes
+
+1. **Cleaner API**: Fields are now callable, making layout code more intuitive
+   ```python
+   yield self.form.name(placeholder="Your name")
+   ```
+
+2. **Flexible Layouts**: Easy to create custom form layouts by subclassing FormLayout
+   ```python
+   class TwoColumnLayout(FormLayout):
+       def compose_form(self):
+           with Horizontal():
+               yield self.form.name()
+               yield self.form.email()
+   ```
+
+3. **Safety**: Prevents duplicate field rendering (1:1 field-to-widget mapping)
+   - Raises `FormError` if same field rendered twice
+
+4. **Backward Compatible**: Existing code continues to work with DefaultFormLayout
+
+## Migration Guide
+
+### Before (v0.8)
+```python
+class MyForm(Form):
+    name = StringField(label="Name")
+    
+form = MyForm()
+rendered = form.render()
+```
+
+### After (v0.9-dev1)
+```python
+# Still works exactly the same!
+class MyForm(Form):
+    name = StringField(label="Name")
+    
+form = MyForm()
+rendered = form.render()
+
+# But now you can also do custom layouts:
+class MyLayout(FormLayout):
+    def compose_form(self):
+        yield Label("Custom Layout")
+        yield self.form.name(placeholder="Enter name")
+        yield Button("Submit", id="submit")
+
+form = MyForm(layout_class=MyLayout)
+rendered = form.render()
+```
+
+## Breaking Changes
+
+⚠️ **Potential Breaking Changes:**
+
+1. **RenderedForm class removed**
+   - If code directly instantiated `RenderedForm`, use `DefaultFormLayout` instead
+   - Message handlers that checked `isinstance(x, RenderedForm)` need updating
+
+2. **Message structure changed**
+   - `Form.Submitted` and `Form.Cancelled` now receive `layout` instead of `r_form`
+   - `message.form` now refers to the layout (backward compatible)
+   - To access actual form: `message.layout.form`
+
+3. **render_type parameter removed**
+   - Use `layout_class` parameter instead
+   - Applies to both `BaseForm.__init__()` and subclasses
+
+## Testing Requirements
+
+The following areas need test updates:
+
+1. **Test files referencing RenderedForm:**
+   - Replace `RenderedForm` imports with `DefaultFormLayout`
+   - Update assertions checking widget type
+
+2. **Test message handling:**
+   - Update to use `message.layout` instead of `message.form` for layout
+   - Or use `message.form` (backward compatible alias)
+
+3. **New tests needed:**
+   - BoundField `__call__()` with various kwargs
+   - Duplicate field rendering raises FormError
+   - Custom layout classes
+   - Field rendering tracking
+
+## Files Modified
+
+- `src/textual_wtf/bound_fields.py` - Added __call__ method
+- `src/textual_wtf/fields.py` - Updated create_widget()
+- `src/textual_wtf/forms.py` - Removed RenderedForm, updated BaseForm/Form
+- `src/textual_wtf/layouts.py` - NEW FILE
+- `src/textual_wtf/__init__.py` - Updated exports
+
+## Files Needing Updates
+
+- All test files that import or reference `RenderedForm`
+- Demo applications in `src/textual_wtf/demo/` (likely need updates)
+- Documentation files
+
+## Next Steps
+
+1. Update test suite to use new architecture
+2. Update demo applications
+3. Update documentation
+4. Add new tests for layout system
+5. Consider whether to add validation that all fields were rendered

textual_wtf-0.8.2/CHANGELOG.md

@@ -0,0 +1,139 @@
+# Changelog
+
+## [0.9.0-dev1] - 2025-02-02
+
+### Breaking Changes
+
+**Major architectural refactoring: Form/Layout separation**
+
+This release introduces a clean separation between form logic (data and validation) and form presentation (layout and rendering). This is a **breaking change** but provides much better flexibility and follows Textual best practices.
+
+#### What Changed
+
+1. **RenderedForm removed** - Forms are no longer widgets themselves
+2. **FormLayout introduced** - New base class for creating form layouts
+3. **Form.render() now returns FormLayout** - Not a breaking API change, but returns a different type
+4. **BoundField is now callable** - WTForms-style widget rendering: `field()`
+
+#### Migration Guide
+
+**Before (v0.8.x):**
+```python
+form = MyForm(data={'name': 'Alice'})
+app.mount(form.render())  # Returns RenderedForm (a widget)
+
+# Message handling
+@on(Form.Submitted)
+def handle_submit(self, event):
+    data = event.form.get_data()  # event.form was RenderedForm
+```
+
+**After (v0.9.x):**
+```python
+form = MyForm(data={'name': 'Alice'})
+app.mount(form.render())  # Returns DefaultFormLayout (a widget)
+
+# Message handling - slightly different
+@on(Form.Submitted)
+def handle_submit(self, event):
+    data = event.form.get_data()  # event.form is now the Form instance
+    # event.layout is the FormLayout widget
+```
+
+#### New Capabilities
+
+**1. Custom Layouts**
+
+You can now create custom layouts by subclassing `FormLayout`:
+
+```python
+from textual_wtf import FormLayout
+from textual.containers import Horizontal, Vertical
+
+class TwoColumnLayout(FormLayout):
+    def compose_form(self):
+        with Horizontal():
+            with Vertical():
+                yield self.render_field('first_name')
+                yield self.render_field('email')
+            with Vertical():
+                yield self.render_field('last_name')
+                yield self.render_field('phone')
+        
+        # Render submit buttons
+        # ... (see DefaultFormLayout for button example)
+
+# Use it
+form = ContactForm()
+app.mount(TwoColumnLayout(form))
+```
+
+**2. Same Form, Different Layouts**
+
+Since Form is just data, you can render the same form instance with different layouts:
+
+```python
+form = UserProfileForm()
+
+# Desktop view
+desktop_panel.mount(DefaultFormLayout(form))
+
+# Mobile view (after unmounting desktop)
+mobile_panel.mount(CompactFormLayout(form))
+```
+
+**3. Callable BoundFields (WTForms-style)**
+
+Fields can now be called to get their widgets:
+
+```python
+class CustomLayout(FormLayout):
+    def compose_form(self):
+        # Call field to get widget
+        yield self.form.fields['name']()
+        
+        # Or with configuration
+        yield self.form.fields['email'](placeholder="Enter email")
+```
+
+**4. Duplicate Rendering Prevention**
+
+The layout system prevents accidentally rendering the same field twice:
+
+```python
+class BadLayout(FormLayout):
+    def compose_form(self):
+        yield self.render_field('name')
+        yield self.render_field('name')  # Raises DuplicateFieldRenderError
+```
+
+### Added
+
+- `FormLayout` - Base class for custom form layouts
+- `DefaultFormLayout` - Default vertical layout (replicates old RenderedForm behavior)
+- `DuplicateFieldRenderError` - Exception raised when field rendered twice
+- `BoundField.__call__()` - Make fields callable to get widgets
+- `Field.create_widget(override_kwargs)` - Accept optional kwargs for widget configuration
+
+### Changed
+
+- `Form` is no longer a widget - use `form.render()` to get a FormLayout widget
+- `Form.Submitted` message now has `.layout` (FormLayout) and `.form` (Form) attributes
+- `Form.Cancelled` message now has `.layout` (FormLayout) and `.form` (Form) attributes
+- Validation logic moved from Form to FormLayout
+
+### Removed
+
+- `RenderedForm` class - replaced by `DefaultFormLayout`
+- `BaseForm.render_type` parameter - use `form.render(layout_class=...)` instead
+- `BaseForm.validate()` method - now on FormLayout
+
+### Internal
+
+- Better separation of concerns: Form = business logic, Layout = presentation
+- Layouts are composable Textual widgets
+- Forms are pure Python objects (no widget inheritance)
+
+## [0.8.0] - Previous Release
+
+(See previous changelog entries...)