textual-wtf 0.8.0__py3-none-any.whl

textual_wtf/demo/nested_once_form.py

@@ -0,0 +1,165 @@
+"""Form Composition Example with results display"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Container
+from textual.screen import Screen
+from textual.widgets import Static
+from textual_wtf import Form, StringField
+from textual_wtf.demo.results_screen import ResultsDisplayScreen
+
+# Define reusable forms
+class AddressForm(Form):
+    """Reusable address form"""
+
+    street = StringField(label="Street Address", required=True)
+    city = StringField(label="City", required=True)
+    state = StringField(label="State/Province", required=True)
+    postal_code = StringField(label="Postal Code", required=True)
+
+
+class PersonalInfoForm(Form):
+    """Personal information form"""
+
+    first_name = StringField(label="First Name", required=True)
+    last_name = StringField(label="Last Name", required=True)
+    email = StringField(label="Email", required=True)
+    phone = StringField(label="Phone")
+
+
+# Compose forms together
+class OrderForm(Form):
+    """Order form composed from reusable forms"""
+
+    # Personal information (no prefix - fields added directly)
+    personal = PersonalInfoForm.compose()
+
+    # Billing address (prefixed - fields added with prefix)
+    billing = AddressForm.compose(prefix="billing")
+
+    # Additional fields
+    notes = StringField(label="Order Notes")
+
+
+class ResultsScreen(ResultsDisplayScreen):
+    """Utility Screen to display form results with SQL-style field lookup demo"""
+
+    def compose(self) -> ComposeResult:
+        with Container(id="results-container"):
+            yield Static(self.result_title, id="results-title")
+
+            if self.form:
+                lookup_lines = [
+                    "Field Attribute Access Examples:",
+                    f"  form.street: {self.form.street.label}:",
+                    f"        [{self.form.street.value}]",
+                    f"  form.billing_street: {self.form.billing_street.label}:",
+                    f"        [{self.form.billing_street.value}]",
+                    f"  form.email: {self.form.email.label}",
+                    f"        [{self.form.email.value}]" "",
+                    "Even though a composed form has a prefix, its fields can be accessed",
+                    "without the prefix so long as they are unique.",
+                ]
+                yield Static("\n".join(lookup_lines), id="field-lookup")
+
+            yield from self.show_data()
+            yield from self.buttons()
+
+
+class ShopScreen(Screen):
+    """Example application using composed forms"""
+
+    CSS = """
+    Screen {
+        align: center middle;
+    }
+
+    RenderedForm {
+        width: 80;
+        height: 100%;
+        max-height: 100%;
+        border: heavy $accent;
+    }
+    """
+
+    def compose(self):
+        """Compose the application"""
+        initial_data = {
+            # Personal info fields (no prefix)
+            'first_name': 'John',
+            'last_name': 'Doe',
+            'email': 'john@example.com',
+            'phone': '555-1234',
+            # Billing address (prefixed)
+            'billing_street': '123 Main St',
+            'billing_city': 'Springfield',
+            'billing_state': 'IL',
+            'billing_postal_code': '62701',
+            # Shipping address (prefixed)
+            'shipping_street': '456 Oak Ave',
+            'shipping_city': 'Chicago',
+            'shipping_state': 'IL',
+            'shipping_postal_code': '60601',
+            # Additional fields
+            'same_as_billing': False,
+            'notes': 'Please ring doorbell',
+        }
+
+        self.form = OrderForm(
+            title="Order Form - Composed from Reusable Forms", data=initial_data
+        )
+        yield self.form.render()
+
+    def on_form_submitted(self, event):
+        """Handle form submission"""
+        data = event.form.get_data()
+
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        # Pass form for field lookup demo
+        self.app.push_screen(
+            ResultsScreen("Order Submitted!", data, event.form.form), check_reset
+        )
+
+    def on_form_cancelled(self, event):
+        """Handle form cancellation"""
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        self.app.push_screen(ResultsScreen("Order Cancelled", None), check_reset)
+
+    def reset_form(self):
+        """Clear form and create fresh one"""
+        old_form = self.query_one("RenderedForm")
+        old_form.remove()
+
+        self.form = OrderForm(title="Order Form - Composed from Reusable Forms")
+        self.mount(self.form.render())
+
+
+def ShopApp(App):
+
+    def on_mount(self):
+        self.app.push_screen(ShopScreen(), callback=self.exit_app)
+
+    def exit_app(self, result=None) -> None:
+        """Called when BasicFormScreen is dismissed."""
+        self.exit(result)
+
+
+def main():
+    """Run the example"""
+    app = ShopApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

textual_wtf/demo/nested_twice_form.py

@@ -0,0 +1,170 @@
+"""Form Composition Example with results display"""
+from textual.app import App, ComposeResult
+from textual.containers import Container
+from textual.screen import Screen
+from textual.widgets import Static
+from textual_wtf import Form, StringField, BooleanField
+from textual_wtf.demo.results_screen import ResultsDisplayScreen
+
+
+# Define reusable forms
+class AddressForm(Form):
+    """Reusable address form"""
+    street = StringField(label="Street Address", required=True)
+    city = StringField(label="City", required=True)
+    state = StringField(label="State/Province", required=True)
+    postal_code = StringField(label="Postal Code", required=True)
+
+
+class PersonalInfoForm(Form):
+    """Personal information form"""
+    first_name = StringField(label="First Name", required=True)
+    last_name = StringField(label="Last Name", required=True)
+    email = StringField(label="Email", required=True)
+    phone = StringField(label="Phone")
+
+
+# Compose forms together
+class OrderForm(Form):
+    """Order form composed from reusable forms"""
+
+    # Personal information (no prefix - fields added directly)
+    personal = PersonalInfoForm.compose()
+
+    # Billing address (prefixed)
+    billing = AddressForm.compose(prefix='billing')
+
+    # Shipping address (prefixed)
+    shipping = AddressForm.compose(prefix='shipping')
+
+    # Additional fields
+    same_as_billing = BooleanField(label="Shipping same as billing")
+    notes = StringField(label="Order Notes")
+
+
+class ResultsScreen(ResultsDisplayScreen):
+    """Utility Screen to display form results with SQL-style field lookup demo"""
+
+    def compose(self) -> ComposeResult:
+        with Container(id="results-container"):
+            yield Static(self.result_title, id="results-title")
+
+            yield from self.show_data()
+
+            # Demonstrate attribute-style field access
+            if self.form:
+                lookup_lines = [
+                    "Field Attribute Access Examples:",
+                    "  form.billing_street: "
+                    + self.form.billing_street.label,
+                    f"        [{self.form.billing_street.value}]",
+                    "  form.email: "
+                    + self.form.email.label
+                    + " (unqualified)",
+                    f"        [{self.form.email.value}]",
+                    "",
+                    "Note: In this case form.street would raise AmbiguousFieldError",
+                    "      because both billing_street and shipping_street exist",
+                ]
+                yield Static("\n".join(lookup_lines), id="field-lookup")
+
+            yield from self.buttons()
+
+
+class ShopScreen(Screen):
+    """Example application using composed forms"""
+
+    CSS = """
+    Screen {
+        align: center middle;
+    }
+
+    RenderedForm {
+        width: 80;
+        height: 100%;
+        max-height: 100%;
+        border: heavy $accent;
+    }
+    """
+
+    def compose(self):
+        """Compose the application"""
+        initial_data = {
+            # Personal info fields (no prefix)
+            'first_name': 'John',
+            'last_name': 'Doe',
+            'email': 'john@example.com',
+            'phone': '555-1234',
+
+            # Billing address (prefixed)
+            'billing_street': '123 Main St',
+            'billing_city': 'Springfield',
+            'billing_state': 'IL',
+            'billing_postal_code': '62701',
+
+            # Shipping address (prefixed)
+            'shipping_street': '456 Oak Ave',
+            'shipping_city': 'Chicago',
+            'shipping_state': 'IL',
+            'shipping_postal_code': '60601',
+
+            # Additional fields
+            'same_as_billing': False,
+            'notes': 'Please ring doorbell'
+        }
+
+        self.form = OrderForm(
+            title="Order Form - Composed from Reusable Forms",
+            data=initial_data
+        )
+        yield self.form.render()
+
+    def on_form_submitted(self, event):
+        """Handle form submission"""
+        data = event.form.get_data()
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        # Pass form for field lookup demo
+        self.app.push_screen(
+            ResultsScreen("Order Submitted!", data, event.form.form), check_reset
+        )
+
+    def on_form_cancelled(self, event):
+        """Handle form cancellation"""
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        self.app.push_screen(ResultsScreen("Order Cancelled", None), check_reset)
+
+    def reset_form(self):
+        """Clear form and create fresh one"""
+        old_form = self.query_one("RenderedForm")
+        old_form.remove()
+
+        self.form = OrderForm(title="Order Form - Composed from Reusable Forms")
+        self.mount(self.form.render())
+
+
+class ShopApp(App):
+
+    def compose(self):
+        yield ShopScreen()
+
+
+def main():
+    """Run the example"""
+    app = ShopApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

textual_wtf/demo/results_screen.py

@@ -0,0 +1,88 @@
+from textual.app import ComposeResult, on
+from textual.containers import Center
+from textual.screen import Screen
+from textual.widgets import Button, Static
+
+class ResultsDisplayScreen(Screen):
+    """
+    Screen to display form results.
+
+    Subclasses must add a compose() method to implement the visual rendering.
+    """
+
+    CSS = """
+    ResultsScreen {
+        align: center middle;
+    }
+
+    #results-container {
+        width: 80%;
+        height: auto;
+        border: heavy green;
+        padding: 1;
+    }
+
+    #results-title {
+        background: green;
+        color: white;
+        width: 100%;
+        height: 1;
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+
+    #results-data {
+        background: $panel;
+        padding: 1;
+        margin: 1 0;
+    }
+
+    #field-lookup {
+        background: $panel;
+        padding: 1;
+        margin: 1 0;
+        border: solid blue;
+    }
+
+    #buttons {
+        align: center middle;
+        margin-top: 1;
+    }
+
+    Button {
+        margin: 0 1;
+    }
+    """
+
+    def __init__(self, title: str, data: dict = None, form=None):
+        super().__init__()
+        self.result_title = title
+        self.data = data
+        self.form = form
+
+    def compose(self) -> ComposeResult:
+        raise NotImplementedError("ResultsScreen subclasses must define a compose() method")
+
+    @on(Button.Pressed, "#new")
+    def new_pressed(self, event: Button.Pressed):
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#exit")
+    def exit_pressed(self, event: Button.Pressed):
+            self.dismiss(False)
+
+    def show_data(self):
+
+        if self.data:
+            # Format data nicely
+            lines = []
+            for key, value in self.data.items():
+                lines.append(f"{key}: {value}")
+            yield Static("\n".join(lines), id="results-data")
+
+    def buttons(self) -> ComposeResult:
+        with Center(id="buttons"):
+            yield Button("New Form", variant="primary", id="new")
+            yield Button("Exit", id="exit")
+
+

textual_wtf/demo/user_registration.py

@@ -0,0 +1,134 @@
+"""User registration form example with results display"""
+from textual.app import App, ComposeResult
+from textual.containers import Container, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Static
+from textual_wtf import Form, StringField, BooleanField
+from textual_wtf.validators import EmailValidator
+from textual_wtf.demo.results_screen import ResultsDisplayScreen
+
+class RegistrationForm(Form):
+    """User registration form"""
+    username = StringField(
+        label="Username",
+        required=True,
+        help_text="Choose a unique username"
+    )
+    email = StringField(
+        label="Email Address",
+        required=True,
+        validators=[EmailValidator()]
+    )
+    full_name = StringField(
+        label="Full Name",
+        required=True
+    )
+    agree_terms = BooleanField(
+        label="I agree to the terms and conditions",
+    )
+
+
+class ResultsScreen(ResultsDisplayScreen):
+    """Utility Screen to display form results"""
+
+    def compose(self) -> ComposeResult:
+        with Container(id="results-container"):
+            yield Static(self.result_title, id="results-title")
+
+            yield from self.show_data()
+            yield from self.buttons()
+
+
+class RegistrationScreen(Screen):
+    """User registration application"""
+
+    TITLE = "User Registration"
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+    ]
+
+    CSS = """
+    Container {
+        align: center middle;
+    }
+
+    #info {
+        width: 60;
+        height: auto;
+        margin: 1 0;
+        padding: 1;
+        border: solid blue;
+    }
+
+    RenderedForm {
+        width: 60;
+        height: auto;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Container():
+            with VerticalScroll():
+                yield Static(
+                    "Welcome! Please fill out the registration form below.",
+                    id="info"
+                )
+                self.form = RegistrationForm(title="Create Account")
+                yield self.form.render()
+
+    def on_form_submitted(self, event: Form.Submitted):
+        """Handle successful registration"""
+        data = event.form.get_data()
+
+        if not data['agree_terms']:
+            self.notify(
+                "You must agree to the terms and conditions",
+                severity="error"
+            )
+            return
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        self.app.push_screen(
+            ResultsScreen("Registration Successful!", data), check_reset
+        )
+
+    def on_form_cancelled(self, event: Form.Cancelled):
+        """Handle registration cancellation"""
+
+        def check_reset(cont):
+            if cont:
+                self.reset_form()
+            else:
+                self.dismiss(cont)
+
+        self.app.push_screen(ResultsScreen("Registration Cancelled", None), check_reset)
+
+    def reset_form(self):
+        """Clear form and create fresh one"""
+        old_form = self.query_one("RenderedForm")
+        old_form.remove()
+        self.form = RegistrationForm(title="Create Account")
+        self.query_one("VerticalScroll").mount(self.form.render())
+
+
+class RegistrationApp(App):
+
+    def on_mount(self):
+        self.app.push_screen(RegistrationScreen(), callback=self.exit_app)
+
+    def exit_app(self, result=None) -> None:
+        """Called when Screen is dismissed."""
+        self.exit(result)
+
+
+def main():
+    RegistrationApp().run()
+
+if __name__ == "__main__":
+    main()
+

textual_wtf/exceptions.py

@@ -0,0 +1,25 @@
+"""Exceptions for textual-wtf"""
+
+
+class ValidationError(Exception):
+    """Raised when field validation fails"""
+
+    def __init__(self, message: str, code: str = None):
+        self.message = message
+        self.code = code
+        super().__init__(self.message)
+
+
+class FieldError(Exception):
+    """Raised when there's an error with field configuration"""
+    pass
+
+
+class FormError(Exception):
+    """Raised when there's an error with form configuration"""
+    pass
+
+
+class AmbiguousFieldError(FieldError):
+    """Raised when an unqualified field name matches multiple fields"""
+    pass