restiny 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

restiny/widgets/dynamic_fields.py

@@ -1,73 +1,111 @@
+from abc import abstractmethod
+from enum import StrEnum
+from pathlib import Path
+
 from textual import on
 from textual.app import ComposeResult
 from textual.containers import VerticalScroll
 from textual.message import Message
-from textual.widgets import Button, Input, Static, Switch
+from textual.widget import Widget
+from textual.widgets import (
+    Button,
+    ContentSwitcher,
+    Input,
+    RadioButton,
+    RadioSet,
+    Switch,
+)
 
+from restiny.widgets.path_chooser import PathChooser
 
-class DynamicField(Static):
-    """
-    Enableable and removable field
-    """
 
-    DEFAULT_CSS = """
-    DynamicField {
-        layout: grid;
-        grid-size: 4 1;
-        grid-columns: auto 1fr 2fr auto; /* Set 1:2 ratio between Inputs */
-    }
-    """
+class DynamicField(Widget):
+    @abstractmethod
+    def compose(self) -> ComposeResult: ...
+
+    @property
+    @abstractmethod
+    def enabled(self) -> bool: ...
+
+    @enabled.setter
+    @abstractmethod
+    def enabled(self, value: bool) -> None: ...
+
+    @property
+    @abstractmethod
+    def key(self) -> str: ...
+
+    @key.setter
+    @abstractmethod
+    def key(self, value: str) -> None: ...
+
+    @property
+    @abstractmethod
+    def value(self) -> str | Path | None: ...
+
+    @value.setter
+    @abstractmethod
+    def value(self, value: str | Path | None) -> None: ...
+
+    @property
+    @abstractmethod
+    def is_empty(self) -> bool: ...
+
+    @property
+    @abstractmethod
+    def is_filled(self) -> bool: ...
 
     class Enabled(Message):
         """
         Sent when the user enables the field.
         """
 
-        def __init__(self, control: 'DynamicField') -> None:
+        def __init__(self, field: 'DynamicField') -> None:
             super().__init__()
-            self._control = control
+            self.field = field
 
+        @property
         def control(self) -> 'DynamicField':
-            return self._control
+            return self.field
 
     class Disabled(Message):
         """
         Sent when the user disables the field.
         """
 
-        def __init__(self, control: 'DynamicField') -> None:
+        def __init__(self, field: 'DynamicField') -> None:
             super().__init__()
-            self._control = control
+            self.field = field
 
         @property
         def control(self) -> 'DynamicField':
-            return self._control
+            return self.field
 
     class Empty(Message):
         """
         Sent when the key input and value input is empty.
         """
 
-        def __init__(self, control: 'DynamicField') -> None:
+        def __init__(self, field: 'DynamicField') -> None:
             super().__init__()
-            self._control = control
+            self.field = field
 
         @property
         def control(self) -> 'DynamicField':
-            return self._control
+            return self.field
 
     class Filled(Message):
         """
         Sent when the key input or value input is filled.
         """
 
-        def __init__(self, control: 'DynamicField') -> None:
+        def __init__(self, field: 'DynamicField') -> None:
             super().__init__()
-            self._control = control
+            self.field = field
 
         @property
         def control(self) -> 'DynamicField':
-            return self._control
+            return self.field
 
     class RemoveRequested(Message):
         """
@@ -76,37 +114,63 @@ class DynamicField(Static):
         to actually remove the field or not.
         """
 
-        def __init__(self, control: 'DynamicField') -> None:
+        def __init__(self, field: 'DynamicField') -> None:
             super().__init__()
-            self._control = control
+            self.field = field
 
         @property
         def control(self) -> 'DynamicField':
-            return self._control
+            return self.field
+
+
+class TextDynamicField(DynamicField):
+    """
+    Enableable and removable field
+    """
+
+    DEFAULT_CSS = """
+    TextDynamicField {
+        width: 100%;
+        height: auto;
+        layout: grid;
+        grid-size: 4 1;
+        grid-columns: auto 1fr 2fr auto; /* Set 1:2 ratio between Inputs */
+    }
+    """
 
     def __init__(
         self, enabled: bool, key: str, value: str, *args, **kwargs
     ) -> None:
         super().__init__(*args, **kwargs)
-
-        # Store initial values temporarily; applied after mounting.
         self._initial_enabled = enabled
         self._initial_key = key
         self._initial_value = value
 
     def compose(self) -> ComposeResult:
-        yield Switch(value=self._initial_enabled, tooltip='Send this field?')
-        yield Input(value=self._initial_key, placeholder='Key', id='input-key')
+        yield Switch(
+            value=self._initial_enabled,
+            tooltip='Send this field?',
+            id='enabled',
+        )
         yield Input(
-            value=self._initial_value, placeholder='Value', id='input-value'
+            value=self._initial_key,
+            placeholder='Key',
+            select_on_focus=False,
+            id='key',
         )
-        yield Button(label='➖', tooltip='Remove field')
+        yield Input(
+            value=self._initial_value,
+            placeholder='Value',
+            select_on_focus=False,
+            id='value',
+        )
+        yield Button(label='➖', tooltip='Remove field', id='remove')
 
-    def on_mount(self) -> None:
-        self.enabled_switch: Switch = self.query_one(Switch)
-        self.key_input: Input = self.query_one('#input-key')
-        self.value_input: Input = self.query_one('#input-value')
-        self.remove_button: Button = self.query_one(Button)
+    async def on_mount(self) -> None:
+        self.enabled_switch = self.query_one('#enabled', Switch)
+        self.key_input = self.query_one('#key', Input)
+        self.value_input = self.query_one('#value', Input)
+        self.remove_button = self.query_one('#remove', Button)
 
     @property
     def enabled(self) -> bool:
@@ -132,57 +196,258 @@ class DynamicField(Static):
     def value(self, value: str) -> None:
         self.value_input.value = value
 
+    @property
+    def is_filled(self) -> bool:
+        return len(self.key_input.value) > 0 or len(self.value_input.value) > 0
+
     @property
     def is_empty(self) -> bool:
-        return (
-            len(self.key_input.value) == 0 and len(self.value_input.value) == 0
+        return not self.is_filled
+
+    @on(Switch.Changed, '#enabled')
+    def on_enabled_or_disabled(self, message: Switch.Changed) -> None:
+        if message.value is True:
+            self.post_message(self.Enabled(field=self))
+        elif message.value is False:
+            self.post_message(message=self.Disabled(field=self))
+
+    @on(Input.Changed, '#key')
+    @on(Input.Changed, '#value')
+    def on_input_changed(self, message: Input.Changed) -> None:
+        self.enabled_switch.value = True
+
+        if self.is_empty:
+            self.post_message(message=self.Empty(field=self))
+        elif self.is_filled:
+            self.post_message(message=self.Filled(field=self))
+
+    @on(Button.Pressed, '#remove')
+    def on_remove_requested(self, message: Button.Pressed) -> None:
+        self.post_message(self.RemoveRequested(field=self))
+
+
+class _ValueKind(StrEnum):
+    TEXT = 'text'
+    FILE = 'file'
+
+
+class TextOrFileDynamicField(DynamicField):
+    DEFAULT_CSS = """
+    TextOrFileDynamicField {
+        width: 100%;
+        height: auto;
+        layout: grid;
+        grid-size: 5 1;
+        grid-columns: auto auto 1fr 2fr auto; /* Set 1:2 ratio between Inputs */
+    }
+
+    TextOrFileDynamicField > RadioSet > RadioButton.-selected {
+        background: $surface;
+    }
+
+    TextOrFileDynamicField > ContentSwitcher > PathChooser{
+        margin-right: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        enabled: bool = False,
+        key: str = '',
+        value: str | Path | None = '',
+        value_kind: _ValueKind = _ValueKind.TEXT,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._initial_enabled = enabled
+        self._initial_key = key
+        self._initial_value = value
+        self._initial_value_kind = value_kind
+
+    def compose(self) -> ComposeResult:
+        with RadioSet(id='value-kind', compact=True):
+            yield RadioButton(
+                label=_ValueKind.TEXT,
+                value=bool(self._initial_value_kind == _ValueKind.TEXT),
+                id='value-kind-text',
+            )
+            yield RadioButton(
+                label=_ValueKind.FILE,
+                value=bool(self._initial_value_kind == _ValueKind.FILE),
+                id='value-kind-file',
+            )
+        yield Switch(
+            value=self._initial_enabled,
+            tooltip='Send this field?',
+            id='enabled',
         )
+        yield Input(
+            value=self._initial_key,
+            placeholder='Key',
+            select_on_focus=False,
+            id='key',
+        )
+        with ContentSwitcher(
+            initial='value-text'
+            if self._initial_value_kind == _ValueKind.TEXT
+            else 'value-file',
+            id='value-kind-switcher',
+        ):
+            yield Input(
+                value=self._initial_value
+                if self._initial_value_kind == _ValueKind.TEXT
+                else '',
+                placeholder='Value',
+                select_on_focus=False,
+                id='value-text',
+            )
+            yield PathChooser.file(
+                path=self._initial_value
+                if self._initial_value_kind == _ValueKind.FILE
+                else None,
+                id='value-file',
+            )
+        yield Button(label='➖', tooltip='Remove field', id='remove')
+
+    def on_mount(self) -> None:
+        self.value_kind_switcher = self.query_one(
+            '#value-kind-switcher', ContentSwitcher
+        )
+
+        self.value_kind_radioset = self.query_one('#value-kind', RadioSet)
+        self.value_kind_text_radio_button = self.query_one(
+            '#value-kind-text', RadioButton
+        )
+        self.value_kind_file_radio_button = self.query_one(
+            '#value-kind-file', RadioButton
+        )
+        self.enabled_switch = self.query_one('#enabled', Switch)
+        self.key_input = self.query_one('#key', Input)
+        self.value_text_input = self.query_one('#value-text', Input)
+        self.value_file_input = self.query_one('#value-file', PathChooser)
+        self.remove_button = self.query_one('#remove', Button)
+
+    @property
+    def enabled(self) -> bool:
+        return self.enabled_switch.value
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self.enabled_switch.value = value
+
+    @property
+    def key(self) -> str:
+        return self.key_input.value
+
+    @key.setter
+    def key(self, value: str) -> None:
+        self.key_input.value = value
+
+    @property
+    def value(self) -> str | Path | None:
+        if self.value_kind == _ValueKind.TEXT:
+            return self.value_text_input.value
+        elif self.value_kind == _ValueKind.FILE:
+            return self.value_file_input.path
+
+    @value.setter
+    def value(self, value: str | Path | None) -> None:
+        if isinstance(value, str):
+            self.value_text_input.value = value
+        elif isinstance(value, Path) or value is None:
+            self.value_file_input.path = value
+
+    @property
+    def value_kind(self) -> _ValueKind:
+        return _ValueKind(self.value_kind_radioset.pressed_button.label)
+
+    @value_kind.setter
+    def value_kind(self, value: _ValueKind) -> None:
+        if value == _ValueKind.TEXT:
+            self.value_kind_switcher.current = 'value-text'
+            self.value_kind_text_radio_button.value = True
+        elif value == _ValueKind.FILE:
+            self.value_kind_switcher.current = 'value-file'
+            self.value_kind_file_radio_button.value = True
 
     @property
     def is_filled(self) -> bool:
-        return len(self.key_input.value) > 0 or len(self.value_input.value) > 0
+        if len(self.key_input.value) > 0:
+            return True
+        elif (
+            self.value_kind == _ValueKind.TEXT
+            and len(self.value_text_input.value) > 0
+        ):
+            return True
+        elif (
+            self.value_kind == _ValueKind.FILE
+            and self.value_file_input.path is not None
+        ):
+            return True
+        else:
+            return False
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.is_filled
+
+    @on(RadioSet.Changed, '#value-kind')
+    def on_value_kind_changed(self, message: RadioSet.Changed) -> None:
+        self.value_kind = _ValueKind(message.pressed.label)
 
-    @on(Switch.Changed)
+    @on(Switch.Changed, '#enabled')
     def on_enabled_or_disabled(self, message: Switch.Changed) -> None:
         if message.value is True:
-            self.post_message(self.Enabled(control=self))
+            self.post_message(self.Enabled(field=self))
         elif message.value is False:
-            self.post_message(message=self.Disabled(control=self))
+            self.post_message(message=self.Disabled(field=self))
 
-    @on(Input.Changed)
-    def on_input_changed(self, message: Input.Changed) -> None:
+    @on(Input.Changed, '#key')
+    @on(Input.Changed, '#value-text')
+    @on(PathChooser.Changed, '#value-file')
+    def on_input_changed(
+        self, message: Input.Changed | PathChooser.Changed
+    ) -> None:
         self.enabled_switch.value = True
 
         if self.is_empty:
-            self.post_message(message=self.Empty(control=self))
+            self.post_message(message=self.Empty(field=self))
         elif self.is_filled:
-            self.post_message(message=self.Filled(control=self))
+            self.post_message(message=self.Filled(field=self))
 
-    @on(Button.Pressed)
+    @on(Button.Pressed, '#remove')
     def on_remove_requested(self, message: Button.Pressed) -> None:
-        self.post_message(self.RemoveRequested(control=self))
+        self.post_message(self.RemoveRequested(field=self))
 
 
-class DynamicFields(Static):
+class DynamicFields(Widget):
     """
     Enableable and removable fields
     """
 
+    DEFAULT_CSS = """
+    DynamicFields {
+        width: auto;
+        height: 1fr;
+    }
+    """
+
     class FieldEmpty(Message):
         """
         Sent when one of the fields becomes empty.
         """
 
         def __init__(
-            self, control: 'DynamicFields', field: DynamicField
+            self, fields: 'DynamicFields', field: DynamicField
         ) -> None:
             super().__init__()
-            self._control = control
+            self.fields = fields
             self.field = field
 
         @property
         def control(self) -> 'DynamicFields':
-            return self._control
+            return self.fields
 
     class FieldFilled(Message):
         """
@@ -190,29 +455,31 @@ class DynamicFields(Static):
         """
 
         def __init__(
-            self, control: 'DynamicFields', field: DynamicField
+            self, fields: 'DynamicFields', field: DynamicField
         ) -> None:
             super().__init__()
-            self._control = control
+            self.fields = fields
             self.field = field
 
         @property
         def control(self) -> 'DynamicFields':
-            return self._control
+            return self.fields
 
-    def __init__(self, fields: list[DynamicField], *args, **kwargs) -> None:
+    def __init__(
+        self,
+        fields: list[DynamicField],
+        *args,
+        **kwargs,
+    ) -> None:
         super().__init__(*args, **kwargs)
-        self._initial_fields = fields
+        self._fields = fields
 
     def compose(self) -> ComposeResult:
-        yield VerticalScroll()
+        with VerticalScroll(can_focus=False):
+            yield from self._fields
 
-    async def on_mount(self) -> None:
-        self.fields_container: VerticalScroll = self.query_one(VerticalScroll)
-
-        # Set initial_fields
-        for field in self._initial_fields:
-            await self.add_field(field=field)
+    def on_mount(self) -> None:
+        self.fields_container = self.query_one(VerticalScroll)
 
     @property
     def fields(self) -> list[DynamicField]:
@@ -220,14 +487,14 @@ class DynamicFields(Static):
 
     @property
     def empty_fields(self) -> list[DynamicField]:
-        return [field for field in self.query(DynamicField) if field.is_empty]
+        return [field for field in self.fields if field.is_empty]
 
     @property
     def filled_fields(self) -> list[DynamicField]:
-        return [field for field in self.query(DynamicField) if field.is_filled]
+        return [field for field in self.fields if field.is_filled]
 
     @property
-    def values(self) -> list[dict[str, str | bool]]:
+    def values(self) -> list[dict[str, str | bool | Path | None]]:
         return [
             {
                 'enabled': field.enabled,
@@ -237,51 +504,63 @@ class DynamicFields(Static):
             for field in self.fields
         ]
 
+    async def add_field(self, field: DynamicField) -> None:
+        await self.fields_container.mount(field)
+
+    def remove_field(self, field: DynamicField) -> None:
+        field.add_class('hidden')
+        field.remove()
+
     @on(DynamicField.Empty)
-    async def on_field_is_empty(self, message: DynamicField.Empty) -> None:
-        await self.remove_field(field=message.control)
+    def _on_field_is_empty(self, message: DynamicField.Empty) -> None:
+        self._focus_neighbor_field_then_remove(field=message.field)
         self.post_message(
-            message=self.FieldEmpty(control=self, field=message.control)
+            message=self.FieldEmpty(fields=self, field=message.field)
         )
 
     @on(DynamicField.Filled)
-    async def on_field_is_filled(self, message: DynamicField.Filled) -> None:
+    async def _on_field_is_filled(self, message: DynamicField.Filled) -> None:
         if len(self.empty_fields) == 0:
-            await self.add_field(
-                field=DynamicField(enabled=False, key='', value='')
-            )
+            field = message.field
+            if isinstance(field, TextDynamicField):
+                await self.add_field(
+                    TextDynamicField(enabled=False, key='', value='')
+                )
+            elif isinstance(field, TextOrFileDynamicField):
+                await self.add_field(
+                    TextOrFileDynamicField(
+                        enabled=False,
+                        key='',
+                        value='',
+                        value_kind=_ValueKind.TEXT,
+                    )
+                )
 
         self.post_message(
-            message=self.FieldFilled(control=self, field=message.control)
+            message=self.FieldFilled(fields=self, field=message.field)
         )
 
     @on(DynamicField.RemoveRequested)
-    async def on_field_remove_requested(
+    def _on_field_remove_requested(
         self, message: DynamicField.RemoveRequested
     ) -> None:
-        await self.remove_field(field=message.control)
+        self._focus_neighbor_field_then_remove(field=message.field)
 
-    async def add_field(self, field: DynamicField) -> None:
-        await self.fields_container.mount(field)
-
-    async def remove_field(self, field: DynamicField) -> None:
+    def _focus_neighbor_field_then_remove(self, field: DynamicField) -> None:
         if len(self.fields) == 1:
             self.app.bell()
             return
-        elif self.fields[-1] is field:  # Last field
+        elif field is self.fields[-1]:
             self.app.bell()
             return
 
-        if self.fields[0] is field:  # First field
-            self.app.screen.focus_next()
-            self.app.screen.focus_next()
-            self.app.screen.focus_next()
-            self.app.screen.focus_next()
-        elif self.fields[-2] is field:  # Penultimate field
-            self.app.screen.focus_previous()
-            self.app.screen.focus_previous()
-            self.app.screen.focus_previous()
-            self.app.screen.focus_previous()
+        field_index = self.fields.index(field)
 
-        field.add_class('hidden')
-        await field.remove()  # Maybe the `await` is unnecessary
+        neighbor_field = None
+        if field_index == 0:
+            neighbor_field = self.fields[field_index + 1]
+        else:
+            neighbor_field = self.fields[field_index - 1]
+
+        self.app.set_focus(neighbor_field.query_one(Input))
+        self.remove_field(field=field)