Skip to content

slider

sleap_nn.config_generator.tui.widgets.slider

Custom slider widget with numeric input.

Provides a slider with integrated numeric input for precise value entry.

Classes:

Name Description
LabeledSlider

Slider widget with label, progress bar, and numeric input.
RangeSlider

Dual-handle range slider for min/max values.

LabeledSlider

Bases: Widget

Slider widget with label, progress bar, and numeric input.

Combines a visual progress bar with a numeric input field for both visual feedback and precise value entry.

Attributes:

Name Type Description
value reactive[float]

Current slider value.
min_value reactive[float]

Minimum allowed value.
max_value reactive[float]

Maximum allowed value.
step reactive[float]

Step increment for value changes.
label reactive[float]

Display label for the slider.

Classes:

Name Description
Changed

Posted when the slider value changes.

Methods:

Name Description
__init__

Initialize the labeled slider.
compose

Compose the slider layout.
decrease

Decrease value by one step.
handle_input_change

Handle direct input changes.
increase

Increase value by one step.
on_mount

Initialize progress bar on mount.
set_value

Programmatically set the slider value.
watch_value

React to value changes.
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
class LabeledSlider(Widget):
    """Slider widget with label, progress bar, and numeric input.

    Combines a visual progress bar with a numeric input field
    for both visual feedback and precise value entry.

    Attributes:
        value: Current slider value.
        min_value: Minimum allowed value.
        max_value: Maximum allowed value.
        step: Step increment for value changes.
        label: Display label for the slider.
    """

    DEFAULT_CSS = """
    LabeledSlider {
        height: auto;
        padding: 0;
        margin: 1 0;
    }

    LabeledSlider .slider-header {
        height: auto;
        width: 100%;
    }

    LabeledSlider .slider-label {
        width: 1fr;
    }

    LabeledSlider .slider-value-display {
        width: auto;
        color: $primary;
        text-style: bold;
        text-align: right;
        min-width: 8;
    }

    LabeledSlider .slider-controls {
        height: auto;
        width: 100%;
        margin-top: 1;
    }

    LabeledSlider ProgressBar {
        width: 1fr;
        margin-right: 1;
    }

    LabeledSlider Input {
        width: 10;
    }

    LabeledSlider .slider-range {
        height: auto;
        width: 100%;
        margin-top: 0;
    }

    LabeledSlider .range-min {
        width: 1fr;
        color: $text-muted;
    }

    LabeledSlider .range-max {
        width: auto;
        color: $text-muted;
        text-align: right;
    }
    """

    value: reactive[float] = reactive(0.0)
    min_value: reactive[float] = reactive(0.0)
    max_value: reactive[float] = reactive(100.0)
    step: reactive[float] = reactive(1.0)

    class Changed(Message):
        """Posted when the slider value changes."""

        def __init__(self, slider: "LabeledSlider", value: float) -> None:
            """Initialize with slider widget and new value."""
            super().__init__()
            self.slider = slider
            self.value = value

        @property
        def control(self) -> "LabeledSlider":
            """Return the slider widget that sent this message."""
            return self.slider

    def __init__(
        self,
        label: str = "Value",
        value: float = 0.0,
        min_value: float = 0.0,
        max_value: float = 100.0,
        step: float = 1.0,
        format_str: str = "{:.1f}",
        unit: str = "",
        show_range: bool = True,
        id: Optional[str] = None,
        classes: Optional[str] = None,
    ):
        """Initialize the labeled slider.

        Args:
            label: Display label.
            value: Initial value.
            min_value: Minimum allowed value.
            max_value: Maximum allowed value.
            step: Step increment.
            format_str: Format string for value display.
            unit: Unit suffix for display (e.g., "px", "%").
            show_range: Whether to show min/max range labels.
            id: Widget ID.
            classes: CSS classes.
        """
        super().__init__(id=id, classes=classes)
        self._label = label
        self._format_str = format_str
        self._unit = unit
        self._show_range = show_range

        # Set initial values
        self.min_value = min_value
        self.max_value = max_value
        self.step = step
        self.value = max(min_value, min(max_value, value))

    def compose(self) -> ComposeResult:
        """Compose the slider layout."""
        with Horizontal(classes="slider-header"):
            yield Static(self._label, classes="slider-label")
            yield Static(
                self._format_value(self.value),
                id="value-display",
                classes="slider-value-display",
            )

        with Horizontal(classes="slider-controls"):
            yield ProgressBar(
                total=100,
                show_eta=False,
                show_percentage=False,
                id="progress",
            )
            yield Input(
                value=str(self.value),
                type="number",
                id="input",
            )

        if self._show_range:
            with Horizontal(classes="slider-range"):
                yield Static(
                    self._format_str.format(self.min_value),
                    classes="range-min",
                )
                yield Static(
                    self._format_str.format(self.max_value),
                    classes="range-max",
                )

    def on_mount(self) -> None:
        """Initialize progress bar on mount."""
        self._update_progress()

    def _format_value(self, value: float) -> str:
        """Format value for display."""
        formatted = self._format_str.format(value)
        if self._unit:
            formatted = f"{formatted}{self._unit}"
        return formatted

    def _update_progress(self) -> None:
        """Update the progress bar to match current value."""
        try:
            progress = self.query_one("#progress", ProgressBar)
            if self.max_value > self.min_value:
                percent = (
                    (self.value - self.min_value)
                    / (self.max_value - self.min_value)
                    * 100
                )
                progress.update(progress=percent)
        except Exception:
            pass

    def _update_display(self) -> None:
        """Update the value display."""
        try:
            display = self.query_one("#value-display", Static)
            display.update(self._format_value(self.value))
        except Exception:
            pass

    def watch_value(self, value: float) -> None:
        """React to value changes."""
        self._update_progress()
        self._update_display()

    @on(Input.Changed, "#input")
    def handle_input_change(self, event: Input.Changed) -> None:
        """Handle direct input changes."""
        try:
            new_value = float(event.value)
            # Clamp to range
            new_value = max(self.min_value, min(self.max_value, new_value))
            # Snap to step
            if self.step > 0:
                new_value = round(new_value / self.step) * self.step

            if new_value != self.value:
                self.value = new_value
                self.post_message(self.Changed(self, new_value))
        except ValueError:
            pass

    def increase(self) -> None:
        """Increase value by one step."""
        new_value = min(self.max_value, self.value + self.step)
        if new_value != self.value:
            self.value = new_value
            self._update_input()
            self.post_message(self.Changed(self, new_value))

    def decrease(self) -> None:
        """Decrease value by one step."""
        new_value = max(self.min_value, self.value - self.step)
        if new_value != self.value:
            self.value = new_value
            self._update_input()
            self.post_message(self.Changed(self, new_value))

    def _update_input(self) -> None:
        """Update the input field to match current value."""
        try:
            input_widget = self.query_one("#input", Input)
            input_widget.value = str(self.value)
        except Exception:
            pass

    def set_value(self, value: float) -> None:
        """Programmatically set the slider value.

        Args:
            value: New value to set.
        """
        clamped = max(self.min_value, min(self.max_value, value))
        if clamped != self.value:
            self.value = clamped
            self._update_input()

Changed

Bases: Message

Posted when the slider value changes.

Methods:

Name Description
__init__

Initialize with slider widget and new value.

Attributes:

Name Type Description
control LabeledSlider

Return the slider widget that sent this message.
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
class Changed(Message):
    """Posted when the slider value changes."""

    def __init__(self, slider: "LabeledSlider", value: float) -> None:
        """Initialize with slider widget and new value."""
        super().__init__()
        self.slider = slider
        self.value = value

    @property
    def control(self) -> "LabeledSlider":
        """Return the slider widget that sent this message."""
        return self.slider
control property

Return the slider widget that sent this message.

__init__(slider, value)

Initialize with slider widget and new value.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
 96
 97
 98
 99
100
def __init__(self, slider: "LabeledSlider", value: float) -> None:
    """Initialize with slider widget and new value."""
    super().__init__()
    self.slider = slider
    self.value = value

__init__(label='Value', value=0.0, min_value=0.0, max_value=100.0, step=1.0, format_str='{:.1f}', unit='', show_range=True, id=None, classes=None)

Initialize the labeled slider.

Parameters:

Name Type Description Default
label str

Display label.

 'Value'
value float

Initial value.

 0.0
min_value float

Minimum allowed value.

 0.0
max_value float

Maximum allowed value.

 100.0
step float

Step increment.

 1.0
format_str str

Format string for value display.

 '{:.1f}'
unit str

Unit suffix for display (e.g., "px", "%").

 ''
show_range bool

Whether to show min/max range labels.

 True
id Optional[str]

Widget ID.

 None
classes Optional[str]

CSS classes.

 None
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def __init__(
    self,
    label: str = "Value",
    value: float = 0.0,
    min_value: float = 0.0,
    max_value: float = 100.0,
    step: float = 1.0,
    format_str: str = "{:.1f}",
    unit: str = "",
    show_range: bool = True,
    id: Optional[str] = None,
    classes: Optional[str] = None,
):
    """Initialize the labeled slider.

    Args:
        label: Display label.
        value: Initial value.
        min_value: Minimum allowed value.
        max_value: Maximum allowed value.
        step: Step increment.
        format_str: Format string for value display.
        unit: Unit suffix for display (e.g., "px", "%").
        show_range: Whether to show min/max range labels.
        id: Widget ID.
        classes: CSS classes.
    """
    super().__init__(id=id, classes=classes)
    self._label = label
    self._format_str = format_str
    self._unit = unit
    self._show_range = show_range

    # Set initial values
    self.min_value = min_value
    self.max_value = max_value
    self.step = step
    self.value = max(min_value, min(max_value, value))

compose()

Compose the slider layout.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
def compose(self) -> ComposeResult:
    """Compose the slider layout."""
    with Horizontal(classes="slider-header"):
        yield Static(self._label, classes="slider-label")
        yield Static(
            self._format_value(self.value),
            id="value-display",
            classes="slider-value-display",
        )

    with Horizontal(classes="slider-controls"):
        yield ProgressBar(
            total=100,
            show_eta=False,
            show_percentage=False,
            id="progress",
        )
        yield Input(
            value=str(self.value),
            type="number",
            id="input",
        )

    if self._show_range:
        with Horizontal(classes="slider-range"):
            yield Static(
                self._format_str.format(self.min_value),
                classes="range-min",
            )
            yield Static(
                self._format_str.format(self.max_value),
                classes="range-max",
            )

decrease()

Decrease value by one step.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
243
244
245
246
247
248
249
def decrease(self) -> None:
    """Decrease value by one step."""
    new_value = max(self.min_value, self.value - self.step)
    if new_value != self.value:
        self.value = new_value
        self._update_input()
        self.post_message(self.Changed(self, new_value))

handle_input_change(event)

Handle direct input changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
@on(Input.Changed, "#input")
def handle_input_change(self, event: Input.Changed) -> None:
    """Handle direct input changes."""
    try:
        new_value = float(event.value)
        # Clamp to range
        new_value = max(self.min_value, min(self.max_value, new_value))
        # Snap to step
        if self.step > 0:
            new_value = round(new_value / self.step) * self.step

        if new_value != self.value:
            self.value = new_value
            self.post_message(self.Changed(self, new_value))
    except ValueError:
        pass

increase()

Increase value by one step.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
235
236
237
238
239
240
241
def increase(self) -> None:
    """Increase value by one step."""
    new_value = min(self.max_value, self.value + self.step)
    if new_value != self.value:
        self.value = new_value
        self._update_input()
        self.post_message(self.Changed(self, new_value))

on_mount()

Initialize progress bar on mount.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
180
181
182
def on_mount(self) -> None:
    """Initialize progress bar on mount."""
    self._update_progress()

set_value(value)

Programmatically set the slider value.

Parameters:

Name Type Description Default
value float

New value to set.

 required
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
259
260
261
262
263
264
265
266
267
268
def set_value(self, value: float) -> None:
    """Programmatically set the slider value.

    Args:
        value: New value to set.
    """
    clamped = max(self.min_value, min(self.max_value, value))
    if clamped != self.value:
        self.value = clamped
        self._update_input()

watch_value(value)

React to value changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
213
214
215
216
def watch_value(self, value: float) -> None:
    """React to value changes."""
    self._update_progress()
    self._update_display()

RangeSlider

Bases: Widget

Dual-handle range slider for min/max values.

Provides visual representation of a range with two adjustable bounds.

Classes:

Name Description
Changed

Posted when the range values change.

Methods:

Name Description
__init__

Initialize the range slider.
compose

Compose the range slider layout.
handle_max_change

Handle max input changes.
handle_min_change

Handle min input changes.
set_range

Programmatically set the range values.
watch_max_val

React to max value changes.
watch_min_val

React to min value changes.
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
class RangeSlider(Widget):
    """Dual-handle range slider for min/max values.

    Provides visual representation of a range with two adjustable bounds.
    """

    DEFAULT_CSS = """
    RangeSlider {
        height: auto;
        padding: 0;
        margin: 1 0;
    }

    RangeSlider .range-header {
        height: auto;
        width: 100%;
    }

    RangeSlider .range-label {
        width: 1fr;
    }

    RangeSlider .range-value-display {
        width: auto;
        color: $primary;
        text-style: bold;
    }

    RangeSlider .range-inputs {
        height: auto;
        width: 100%;
        margin-top: 1;
    }

    RangeSlider Input {
        width: 1fr;
    }

    RangeSlider .range-separator {
        width: auto;
        padding: 0 1;
        color: $text-muted;
    }
    """

    min_val: reactive[float] = reactive(0.0)
    max_val: reactive[float] = reactive(100.0)

    class Changed(Message):
        """Posted when the range values change."""

        def __init__(
            self, slider: "RangeSlider", min_val: float, max_val: float
        ) -> None:
            """Initialize with slider widget and new range values."""
            super().__init__()
            self.slider = slider
            self.min_val = min_val
            self.max_val = max_val

        @property
        def control(self) -> "RangeSlider":
            """Return the slider widget that sent this message."""
            return self.slider

    def __init__(
        self,
        label: str = "Range",
        min_val: float = 0.0,
        max_val: float = 100.0,
        limit_min: float = -1000.0,
        limit_max: float = 1000.0,
        step: float = 1.0,
        format_str: str = "{:.1f}",
        unit: str = "",
        symmetric: bool = False,
        id: Optional[str] = None,
        classes: Optional[str] = None,
    ):
        """Initialize the range slider.

        Args:
            label: Display label.
            min_val: Initial minimum value.
            max_val: Initial maximum value.
            limit_min: Absolute minimum allowed.
            limit_max: Absolute maximum allowed.
            step: Step increment.
            format_str: Format string for values.
            unit: Unit suffix for display.
            symmetric: If True, min = -max when adjusting.
            id: Widget ID.
            classes: CSS classes.
        """
        super().__init__(id=id, classes=classes)
        self._label = label
        self._limit_min = limit_min
        self._limit_max = limit_max
        self._step = step
        self._format_str = format_str
        self._unit = unit
        self._symmetric = symmetric

        self.min_val = min_val
        self.max_val = max_val

    def compose(self) -> ComposeResult:
        """Compose the range slider layout."""
        with Horizontal(classes="range-header"):
            yield Static(self._label, classes="range-label")
            yield Static(
                self._format_range(),
                id="range-display",
                classes="range-value-display",
            )

        with Horizontal(classes="range-inputs"):
            yield Input(
                value=str(self.min_val),
                type="number",
                id="min-input",
            )
            yield Static("to", classes="range-separator")
            yield Input(
                value=str(self.max_val),
                type="number",
                id="max-input",
            )

    def _format_range(self) -> str:
        """Format range for display."""
        min_str = self._format_str.format(self.min_val)
        max_str = self._format_str.format(self.max_val)
        if self._unit:
            return f"{min_str} to {max_str}{self._unit}"
        return f"{min_str} to {max_str}"

    def _update_display(self) -> None:
        """Update the range display."""
        try:
            display = self.query_one("#range-display", Static)
            display.update(self._format_range())
        except Exception:
            pass

    def watch_min_val(self, value: float) -> None:
        """React to min value changes."""
        self._update_display()

    def watch_max_val(self, value: float) -> None:
        """React to max value changes."""
        self._update_display()

    @on(Input.Changed, "#min-input")
    def handle_min_change(self, event: Input.Changed) -> None:
        """Handle min input changes."""
        try:
            new_min = float(event.value)
            new_min = max(self._limit_min, min(self.max_val, new_min))
            if self._step > 0:
                new_min = round(new_min / self._step) * self._step

            if self._symmetric:
                self.max_val = -new_min

            if new_min != self.min_val:
                self.min_val = new_min
                self.post_message(self.Changed(self, self.min_val, self.max_val))
        except ValueError:
            pass

    @on(Input.Changed, "#max-input")
    def handle_max_change(self, event: Input.Changed) -> None:
        """Handle max input changes."""
        try:
            new_max = float(event.value)
            new_max = max(self.min_val, min(self._limit_max, new_max))
            if self._step > 0:
                new_max = round(new_max / self._step) * self._step

            if self._symmetric:
                self.min_val = -new_max

            if new_max != self.max_val:
                self.max_val = new_max
                self.post_message(self.Changed(self, self.min_val, self.max_val))
        except ValueError:
            pass

    def set_range(self, min_val: float, max_val: float) -> None:
        """Programmatically set the range values.

        Args:
            min_val: New minimum value.
            max_val: New maximum value.
        """
        self.min_val = max(self._limit_min, min(max_val, min_val))
        self.max_val = max(min_val, min(self._limit_max, max_val))
        try:
            self.query_one("#min-input", Input).value = str(self.min_val)
            self.query_one("#max-input", Input).value = str(self.max_val)
        except Exception:
            pass

Changed

Bases: Message

Posted when the range values change.

Methods:

Name Description
__init__

Initialize with slider widget and new range values.

Attributes:

Name Type Description
control RangeSlider

Return the slider widget that sent this message.
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
class Changed(Message):
    """Posted when the range values change."""

    def __init__(
        self, slider: "RangeSlider", min_val: float, max_val: float
    ) -> None:
        """Initialize with slider widget and new range values."""
        super().__init__()
        self.slider = slider
        self.min_val = min_val
        self.max_val = max_val

    @property
    def control(self) -> "RangeSlider":
        """Return the slider widget that sent this message."""
        return self.slider
control property

Return the slider widget that sent this message.

__init__(slider, min_val, max_val)

Initialize with slider widget and new range values.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
322
323
324
325
326
327
328
329
def __init__(
    self, slider: "RangeSlider", min_val: float, max_val: float
) -> None:
    """Initialize with slider widget and new range values."""
    super().__init__()
    self.slider = slider
    self.min_val = min_val
    self.max_val = max_val

__init__(label='Range', min_val=0.0, max_val=100.0, limit_min=-1000.0, limit_max=1000.0, step=1.0, format_str='{:.1f}', unit='', symmetric=False, id=None, classes=None)

Initialize the range slider.

Parameters:

Name Type Description Default
label str

Display label.

 'Range'
min_val float

Initial minimum value.

 0.0
max_val float

Initial maximum value.

 100.0
limit_min float

Absolute minimum allowed.

 -1000.0
limit_max float

Absolute maximum allowed.

 1000.0
step float

Step increment.

 1.0
format_str str

Format string for values.

 '{:.1f}'
unit str

Unit suffix for display.

 ''
symmetric bool

If True, min = -max when adjusting.

 False
id Optional[str]

Widget ID.

 None
classes Optional[str]

CSS classes.

 None
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
def __init__(
    self,
    label: str = "Range",
    min_val: float = 0.0,
    max_val: float = 100.0,
    limit_min: float = -1000.0,
    limit_max: float = 1000.0,
    step: float = 1.0,
    format_str: str = "{:.1f}",
    unit: str = "",
    symmetric: bool = False,
    id: Optional[str] = None,
    classes: Optional[str] = None,
):
    """Initialize the range slider.

    Args:
        label: Display label.
        min_val: Initial minimum value.
        max_val: Initial maximum value.
        limit_min: Absolute minimum allowed.
        limit_max: Absolute maximum allowed.
        step: Step increment.
        format_str: Format string for values.
        unit: Unit suffix for display.
        symmetric: If True, min = -max when adjusting.
        id: Widget ID.
        classes: CSS classes.
    """
    super().__init__(id=id, classes=classes)
    self._label = label
    self._limit_min = limit_min
    self._limit_max = limit_max
    self._step = step
    self._format_str = format_str
    self._unit = unit
    self._symmetric = symmetric

    self.min_val = min_val
    self.max_val = max_val

compose()

Compose the range slider layout.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
def compose(self) -> ComposeResult:
    """Compose the range slider layout."""
    with Horizontal(classes="range-header"):
        yield Static(self._label, classes="range-label")
        yield Static(
            self._format_range(),
            id="range-display",
            classes="range-value-display",
        )

    with Horizontal(classes="range-inputs"):
        yield Input(
            value=str(self.min_val),
            type="number",
            id="min-input",
        )
        yield Static("to", classes="range-separator")
        yield Input(
            value=str(self.max_val),
            type="number",
            id="max-input",
        )

handle_max_change(event)

Handle max input changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
@on(Input.Changed, "#max-input")
def handle_max_change(self, event: Input.Changed) -> None:
    """Handle max input changes."""
    try:
        new_max = float(event.value)
        new_max = max(self.min_val, min(self._limit_max, new_max))
        if self._step > 0:
            new_max = round(new_max / self._step) * self._step

        if self._symmetric:
            self.min_val = -new_max

        if new_max != self.max_val:
            self.max_val = new_max
            self.post_message(self.Changed(self, self.min_val, self.max_val))
    except ValueError:
        pass

handle_min_change(event)

Handle min input changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
@on(Input.Changed, "#min-input")
def handle_min_change(self, event: Input.Changed) -> None:
    """Handle min input changes."""
    try:
        new_min = float(event.value)
        new_min = max(self._limit_min, min(self.max_val, new_min))
        if self._step > 0:
            new_min = round(new_min / self._step) * self._step

        if self._symmetric:
            self.max_val = -new_min

        if new_min != self.min_val:
            self.min_val = new_min
            self.post_message(self.Changed(self, self.min_val, self.max_val))
    except ValueError:
        pass

set_range(min_val, max_val)

Programmatically set the range values.

Parameters:

Name Type Description Default
min_val float

New minimum value.

 required
max_val float

New maximum value.

 required
Source code in sleap_nn/config_generator/tui/widgets/slider.py 
460
461
462
463
464
465
466
467
468
469
470
471
472
473
def set_range(self, min_val: float, max_val: float) -> None:
    """Programmatically set the range values.

    Args:
        min_val: New minimum value.
        max_val: New maximum value.
    """
    self.min_val = max(self._limit_min, min(max_val, min_val))
    self.max_val = max(min_val, min(self._limit_max, max_val))
    try:
        self.query_one("#min-input", Input).value = str(self.min_val)
        self.query_one("#max-input", Input).value = str(self.max_val)
    except Exception:
        pass

watch_max_val(value)

React to max value changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
420
421
422
def watch_max_val(self, value: float) -> None:
    """React to max value changes."""
    self._update_display()

watch_min_val(value)

React to min value changes.

Source code in sleap_nn/config_generator/tui/widgets/slider.py 
416
417
418
def watch_min_val(self, value: float) -> None:
    """React to min value changes."""
    self._update_display()