|
|
"""Module contains the class to create a number prompt.""" |
|
|
import re |
|
|
from decimal import Decimal |
|
|
from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union, cast |
|
|
|
|
|
from prompt_toolkit.application.application import Application |
|
|
from prompt_toolkit.buffer import Buffer |
|
|
from prompt_toolkit.filters.base import Condition |
|
|
from prompt_toolkit.filters.cli import IsDone |
|
|
from prompt_toolkit.keys import Keys |
|
|
from prompt_toolkit.layout.containers import ( |
|
|
ConditionalContainer, |
|
|
HorizontalAlign, |
|
|
HSplit, |
|
|
VSplit, |
|
|
Window, |
|
|
) |
|
|
from prompt_toolkit.layout.controls import ( |
|
|
BufferControl, |
|
|
DummyControl, |
|
|
FormattedTextControl, |
|
|
) |
|
|
from prompt_toolkit.layout.dimension import Dimension, LayoutDimension |
|
|
from prompt_toolkit.layout.layout import Layout |
|
|
from prompt_toolkit.lexers.base import SimpleLexer |
|
|
from prompt_toolkit.validation import ValidationError |
|
|
|
|
|
from InquirerPy.base.complex import BaseComplexPrompt, FakeDocument |
|
|
from InquirerPy.containers.instruction import InstructionWindow |
|
|
from InquirerPy.containers.validation import ValidationWindow |
|
|
from InquirerPy.enum import INQUIRERPY_QMARK_SEQUENCE |
|
|
from InquirerPy.exceptions import InvalidArgument |
|
|
from InquirerPy.utils import ( |
|
|
InquirerPyDefault, |
|
|
InquirerPyKeybindings, |
|
|
InquirerPyMessage, |
|
|
InquirerPySessionResult, |
|
|
InquirerPyStyle, |
|
|
InquirerPyValidate, |
|
|
) |
|
|
|
|
|
if TYPE_CHECKING: |
|
|
from prompt_toolkit.key_binding.key_processor import KeyPressEvent |
|
|
|
|
|
__all__ = ["NumberPrompt"] |
|
|
|
|
|
|
|
|
class NumberPrompt(BaseComplexPrompt): |
|
|
"""Create a input prompts that only takes number as input. |
|
|
|
|
|
A wrapper class around :class:`~prompt_toolkit.application.Application`. |
|
|
|
|
|
Args: |
|
|
message: The question to ask the user. |
|
|
Refer to :ref:`pages/dynamic:message` documentation for more details. |
|
|
style: An :class:`InquirerPyStyle` instance. |
|
|
Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details. |
|
|
vi_mode: Use vim keybinding for the prompt. |
|
|
Refer to :ref:`pages/kb:Keybindings` documentation for more details. |
|
|
default: Set the default value of the prompt. |
|
|
You can enter either the floating value or integer value as the default. |
|
|
Refer to :ref:`pages/dynamic:default` documentation for more details. |
|
|
float_allowed: Allow decimal input. This will change the prompt to have 2 input buffer, one for the |
|
|
whole value and one for the integral value. |
|
|
min_allowed: Set the minimum value of the prompt. When the input value goes below this value, it |
|
|
will automatically reset to this value. |
|
|
max_allowed: Set the maximum value of the prompt. When the inptu value goes above this value, it |
|
|
will automatically reset to this value. |
|
|
qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered. |
|
|
amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered. |
|
|
decimal_symbol: Decimal point symbol. Custom symbol to display as the decimal point. |
|
|
replace_mode: Start each input buffer in replace mode if default value is 0. |
|
|
When typing, it will replace the 0 with the new value. The replace mode will be disabled once the value |
|
|
is changed. |
|
|
instruction: Short instruction to display next to the question. |
|
|
long_instruction: Long instructions to display at the bottom of the prompt. |
|
|
validate: Add validation to user input. |
|
|
Refer to :ref:`pages/validator:Validator` documentation for more details. |
|
|
invalid_message: Error message to display when user input is invalid. |
|
|
Refer to :ref:`pages/validator:Validator` documentation for more details. |
|
|
invalid_message: Error message to display when user input is invalid. |
|
|
Refer to :ref:`pages/validator:Validator` documentation for more details. |
|
|
transformer: A function which performs additional transformation on the value that gets printed to the terminal. |
|
|
Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. |
|
|
Refer to :ref:`pages/dynamic:transformer` documentation for more details. |
|
|
filter: A function which performs additional transformation on the result. |
|
|
This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. |
|
|
Refer to :ref:`pages/dynamic:filter` documentation for more details. |
|
|
keybindings: Customise the builtin keybindings. |
|
|
Refer to :ref:`pages/kb:Keybindings` for more details. |
|
|
wrap_lines: Soft wrap question lines when question exceeds the terminal width. |
|
|
raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result |
|
|
will be `None` and the question is skiped. |
|
|
mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped. |
|
|
mandatory_message: Error message to show when user attempts to skip mandatory prompt. |
|
|
session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`. |
|
|
|
|
|
Examples: |
|
|
>>> from InquirerPy import inquirer |
|
|
>>> result = inquirer.number(message="Enter number:").execute() |
|
|
>>> print(result) |
|
|
0 |
|
|
""" |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
message: InquirerPyMessage, |
|
|
style: Optional[InquirerPyStyle] = None, |
|
|
vi_mode: bool = False, |
|
|
default: InquirerPyDefault = 0, |
|
|
float_allowed: bool = False, |
|
|
max_allowed: Optional[Union[int, float]] = None, |
|
|
min_allowed: Optional[Union[int, float]] = None, |
|
|
decimal_symbol: str = ". ", |
|
|
replace_mode: bool = False, |
|
|
qmark: str = INQUIRERPY_QMARK_SEQUENCE, |
|
|
amark: str = "?", |
|
|
instruction: str = "", |
|
|
long_instruction: str = "", |
|
|
validate: Optional[InquirerPyValidate] = None, |
|
|
invalid_message: str = "Invalid input", |
|
|
transformer: Optional[Callable[[str], Any]] = None, |
|
|
filter: Optional[Callable[[str], Any]] = None, |
|
|
keybindings: Optional[InquirerPyKeybindings] = None, |
|
|
wrap_lines: bool = True, |
|
|
raise_keyboard_interrupt: bool = True, |
|
|
mandatory: bool = True, |
|
|
mandatory_message: str = "Mandatory prompt", |
|
|
session_result: Optional[InquirerPySessionResult] = None, |
|
|
) -> None: |
|
|
super().__init__( |
|
|
message=message, |
|
|
style=style, |
|
|
vi_mode=vi_mode, |
|
|
qmark=qmark, |
|
|
amark=amark, |
|
|
transformer=transformer, |
|
|
filter=filter, |
|
|
invalid_message=invalid_message, |
|
|
validate=validate, |
|
|
instruction=instruction, |
|
|
long_instruction=long_instruction, |
|
|
wrap_lines=wrap_lines, |
|
|
raise_keyboard_interrupt=raise_keyboard_interrupt, |
|
|
mandatory=mandatory, |
|
|
mandatory_message=mandatory_message, |
|
|
session_result=session_result, |
|
|
) |
|
|
|
|
|
self._float = float_allowed |
|
|
self._is_float = Condition(lambda: self._float) |
|
|
self._max = max_allowed |
|
|
self._min = min_allowed |
|
|
self._value_error_message = "Remove any non-integer value" |
|
|
self._decimal_symbol = decimal_symbol |
|
|
self._whole_replace = False |
|
|
self._integral_replace = False |
|
|
self._replace_mode = replace_mode |
|
|
|
|
|
self._leading_zero_pattern = re.compile(r"^(0*)[0-9]+.*") |
|
|
self._sn_pattern = re.compile(r"^.*E-.*") |
|
|
self._no_default = False |
|
|
|
|
|
if default is None: |
|
|
default = 0 |
|
|
self._no_default = True |
|
|
|
|
|
if isinstance(default, Callable): |
|
|
default = cast(Callable, default)(session_result) |
|
|
if self._float: |
|
|
default = Decimal(str(float(cast(int, default)))) |
|
|
if self._float: |
|
|
if not isinstance(default, float) and not isinstance(default, Decimal): |
|
|
raise InvalidArgument( |
|
|
f"{type(self).__name__} argument 'default' should return type of float or Decimal" |
|
|
) |
|
|
elif not isinstance(default, int): |
|
|
raise InvalidArgument( |
|
|
f"{type(self).__name__} argument 'default' should return type of int" |
|
|
) |
|
|
self._default = default |
|
|
|
|
|
if keybindings is None: |
|
|
keybindings = {} |
|
|
self.kb_maps = { |
|
|
"down": [ |
|
|
{"key": "down"}, |
|
|
{"key": "c-n", "filter": ~self._is_vim_edit}, |
|
|
{"key": "j", "filter": self._is_vim_edit}, |
|
|
], |
|
|
"up": [ |
|
|
{"key": "up"}, |
|
|
{"key": "c-p", "filter": ~self._is_vim_edit}, |
|
|
{"key": "k", "filter": self._is_vim_edit}, |
|
|
], |
|
|
"left": [ |
|
|
{"key": "left"}, |
|
|
{"key": "c-b", "filter": ~self._is_vim_edit}, |
|
|
{"key": "h", "filter": self._is_vim_edit}, |
|
|
], |
|
|
"right": [ |
|
|
{"key": "right"}, |
|
|
{"key": "c-f", "filter": ~self._is_vim_edit}, |
|
|
{"key": "l", "filter": self._is_vim_edit}, |
|
|
], |
|
|
"dot": [{"key": "."}], |
|
|
"focus": [{"key": Keys.Tab}, {"key": "s-tab"}], |
|
|
"input": [{"key": str(i)} for i in range(10)], |
|
|
"negative_toggle": [{"key": "-"}], |
|
|
**keybindings, |
|
|
} |
|
|
self.kb_func_lookup = { |
|
|
"down": [{"func": self._handle_down}], |
|
|
"up": [{"func": self._handle_up}], |
|
|
"left": [{"func": self._handle_left}], |
|
|
"right": [{"func": self._handle_right}], |
|
|
"focus": [{"func": self._handle_focus}], |
|
|
"input": [{"func": self._handle_input}], |
|
|
"negative_toggle": [{"func": self._handle_negative_toggle}], |
|
|
"dot": [{"func": self._handle_dot}], |
|
|
} |
|
|
|
|
|
@self.register_kb(Keys.Any) |
|
|
def _(_): |
|
|
pass |
|
|
|
|
|
self._whole_width = 1 |
|
|
self._whole_buffer = Buffer( |
|
|
on_text_changed=self._on_whole_text_change, |
|
|
on_cursor_position_changed=self._on_cursor_position_change, |
|
|
) |
|
|
|
|
|
self._integral_width = 1 |
|
|
self._integral_buffer = Buffer( |
|
|
on_text_changed=self._on_integral_text_change, |
|
|
on_cursor_position_changed=self._on_cursor_position_change, |
|
|
) |
|
|
|
|
|
self._whole_window = Window( |
|
|
height=LayoutDimension.exact(1) if not self._wrap_lines else None, |
|
|
content=BufferControl( |
|
|
buffer=self._whole_buffer, |
|
|
lexer=SimpleLexer("class:input"), |
|
|
), |
|
|
width=lambda: Dimension( |
|
|
min=self._whole_width, |
|
|
max=self._whole_width, |
|
|
preferred=self._whole_width, |
|
|
), |
|
|
dont_extend_width=True, |
|
|
) |
|
|
|
|
|
self._integral_window = Window( |
|
|
height=LayoutDimension.exact(1) if not self._wrap_lines else None, |
|
|
content=BufferControl( |
|
|
buffer=self._integral_buffer, |
|
|
lexer=SimpleLexer("class:input"), |
|
|
), |
|
|
width=lambda: Dimension( |
|
|
min=self._integral_width, |
|
|
max=self._integral_width, |
|
|
preferred=self._integral_width, |
|
|
), |
|
|
) |
|
|
|
|
|
self._layout = Layout( |
|
|
HSplit( |
|
|
[ |
|
|
VSplit( |
|
|
[ |
|
|
Window( |
|
|
height=LayoutDimension.exact(1) |
|
|
if not self._wrap_lines |
|
|
else None, |
|
|
content=FormattedTextControl(self._get_prompt_message), |
|
|
wrap_lines=self._wrap_lines, |
|
|
dont_extend_height=True, |
|
|
dont_extend_width=True, |
|
|
), |
|
|
ConditionalContainer(self._whole_window, filter=~IsDone()), |
|
|
ConditionalContainer( |
|
|
Window( |
|
|
height=LayoutDimension.exact(1) |
|
|
if not self._wrap_lines |
|
|
else None, |
|
|
content=FormattedTextControl( |
|
|
[("", self._decimal_symbol)] |
|
|
), |
|
|
wrap_lines=self._wrap_lines, |
|
|
dont_extend_height=True, |
|
|
dont_extend_width=True, |
|
|
), |
|
|
filter=self._is_float & ~IsDone(), |
|
|
), |
|
|
ConditionalContainer( |
|
|
self._integral_window, filter=self._is_float & ~IsDone() |
|
|
), |
|
|
], |
|
|
align=HorizontalAlign.LEFT, |
|
|
), |
|
|
ConditionalContainer( |
|
|
Window(content=DummyControl()), |
|
|
filter=~IsDone() & self._is_displaying_long_instruction, |
|
|
), |
|
|
ValidationWindow( |
|
|
invalid_message=self._get_error_message, |
|
|
filter=self._is_invalid & ~IsDone(), |
|
|
wrap_lines=self._wrap_lines, |
|
|
), |
|
|
InstructionWindow( |
|
|
message=self._long_instruction, |
|
|
filter=~IsDone() & self._is_displaying_long_instruction, |
|
|
wrap_lines=self._wrap_lines, |
|
|
), |
|
|
] |
|
|
), |
|
|
) |
|
|
|
|
|
self.focus = self._whole_window |
|
|
|
|
|
self._application = Application( |
|
|
layout=self._layout, |
|
|
style=self._style, |
|
|
key_bindings=self._kb, |
|
|
after_render=self._after_render, |
|
|
editing_mode=self._editing_mode, |
|
|
) |
|
|
|
|
|
def _fix_sn(self, value: str) -> Tuple[str, str]: |
|
|
"""Fix sciencetific notation format. |
|
|
|
|
|
Args: |
|
|
value: Value to fix. |
|
|
|
|
|
Returns: |
|
|
A tuple of whole buffer text and integral buffer text. |
|
|
""" |
|
|
left, right = value.split("E-") |
|
|
whole_buffer_text = "0" |
|
|
integral_buffer_text = f"{(int(right) - 1) * '0'}{left.replace('.', '')}" |
|
|
return whole_buffer_text, integral_buffer_text |
|
|
|
|
|
def _on_rendered(self, _) -> None: |
|
|
"""Additional processing to adjust buffer content after render.""" |
|
|
if self._no_default: |
|
|
return |
|
|
if not self._float: |
|
|
self._whole_buffer.text = str(self._default) |
|
|
self._integral_buffer.text = "0" |
|
|
else: |
|
|
if self._sn_pattern.match(str(self._default)) is None: |
|
|
whole_buffer_text, integral_buffer_text = str(self._default).split(".") |
|
|
else: |
|
|
whole_buffer_text, integral_buffer_text = self._fix_sn( |
|
|
str(self._default) |
|
|
) |
|
|
self._integral_buffer.text = integral_buffer_text |
|
|
self._whole_buffer.text = whole_buffer_text |
|
|
self._whole_buffer.cursor_position = len(self._whole_buffer.text) |
|
|
self._integral_buffer.cursor_position = len(self._integral_buffer.text) |
|
|
if self._replace_mode: |
|
|
|
|
|
if self._whole_buffer.text == "0": |
|
|
self._whole_replace = True |
|
|
self._whole_buffer.cursor_position = 0 |
|
|
if self._integral_buffer.text == "0": |
|
|
self._integral_replace = True |
|
|
self._integral_buffer.cursor_position = 0 |
|
|
|
|
|
def _handle_number(self, increment: bool) -> None: |
|
|
"""Handle number increment and decrement. |
|
|
|
|
|
Additional processing to handle leading zeros in integral buffer |
|
|
as well as SN notation. |
|
|
|
|
|
Args: |
|
|
increment: Indicate if the operation should increment or decrement. |
|
|
""" |
|
|
if self.buffer_replace: |
|
|
self.buffer_replace = False |
|
|
self.focus_buffer.cursor_position += 1 |
|
|
try: |
|
|
leading_zeros = "" |
|
|
if self.focus_buffer == self._integral_buffer: |
|
|
zeros = self._leading_zero_pattern.match(self._integral_buffer.text) |
|
|
if zeros is not None: |
|
|
leading_zeros = zeros.group(1) |
|
|
current_text_len = len(self.focus_buffer.text) |
|
|
if not self.focus_buffer.text: |
|
|
next_text = "0" |
|
|
next_text_len = 1 |
|
|
else: |
|
|
if not increment: |
|
|
if ( |
|
|
self.focus_buffer == self._integral_buffer |
|
|
and int(self.focus_buffer.text) == 0 |
|
|
): |
|
|
return |
|
|
next_text = leading_zeros + str(int(self.focus_buffer.text) - 1) |
|
|
else: |
|
|
next_text = leading_zeros + str(int(self.focus_buffer.text) + 1) |
|
|
next_text_len = len(next_text) |
|
|
desired_position = ( |
|
|
self.focus_buffer.cursor_position + next_text_len - current_text_len |
|
|
) |
|
|
self.focus_buffer.cursor_position = desired_position |
|
|
self.focus_buffer.text = next_text |
|
|
if self.focus_buffer.cursor_position != desired_position: |
|
|
self.focus_buffer.cursor_position = desired_position |
|
|
except ValueError: |
|
|
self._set_error(message=self._value_error_message) |
|
|
|
|
|
def _handle_down(self, _) -> None: |
|
|
"""Handle down key press.""" |
|
|
self._handle_number(increment=False) |
|
|
|
|
|
def _handle_up(self, _) -> None: |
|
|
"""Handle up key press.""" |
|
|
self._handle_number(increment=True) |
|
|
|
|
|
def _handle_left(self, _) -> None: |
|
|
"""Handle left key press. |
|
|
|
|
|
Move to the left by one cursor position and focus the whole window |
|
|
if applicable. |
|
|
""" |
|
|
self.buffer_replace = False |
|
|
if ( |
|
|
self.focus == self._integral_window |
|
|
and self.focus_buffer.cursor_position == 0 |
|
|
): |
|
|
self.focus = self._whole_window |
|
|
else: |
|
|
self.focus_buffer.cursor_position -= 1 |
|
|
|
|
|
def _handle_right(self, _) -> None: |
|
|
"""Handle right key press. |
|
|
|
|
|
Move to the right by one cursor position and focus the integral window |
|
|
if applicable. |
|
|
""" |
|
|
self.buffer_replace = False |
|
|
if ( |
|
|
self.focus == self._whole_window |
|
|
and self.focus_buffer.cursor_position == len(self.focus_buffer.text) |
|
|
and self._float |
|
|
): |
|
|
self.focus = self._integral_window |
|
|
else: |
|
|
self.focus_buffer.cursor_position += 1 |
|
|
|
|
|
def _handle_enter(self, event: "KeyPressEvent") -> None: |
|
|
"""Handle enter event and answer/close the prompt.""" |
|
|
if not self._float and not self._whole_buffer.text: |
|
|
result = "" |
|
|
elif ( |
|
|
self._float |
|
|
and not self._whole_buffer.text |
|
|
and not self._integral_buffer.text |
|
|
): |
|
|
result = "" |
|
|
else: |
|
|
result = str(self.value) |
|
|
|
|
|
try: |
|
|
fake_document = FakeDocument(result) |
|
|
self._validator.validate(fake_document) |
|
|
except ValidationError as e: |
|
|
self._set_error(str(e)) |
|
|
else: |
|
|
self.status["answered"] = True |
|
|
self.status["result"] = result |
|
|
event.app.exit(result=result) |
|
|
|
|
|
def _handle_dot(self, _) -> None: |
|
|
"""Focus the integral window if `float_allowed`.""" |
|
|
self._handle_focus(_, self._integral_window) |
|
|
|
|
|
def _handle_focus(self, _, window: Optional[Window] = None) -> None: |
|
|
"""Focus either the integral window or whole window.""" |
|
|
if not self._float: |
|
|
return |
|
|
if window is not None: |
|
|
self.focus = window |
|
|
return |
|
|
if self.focus == self._whole_window: |
|
|
self.focus = self._integral_window |
|
|
else: |
|
|
self.focus = self._whole_window |
|
|
|
|
|
def _handle_input(self, event: "KeyPressEvent") -> None: |
|
|
"""Handle user input of numbers. |
|
|
|
|
|
Buffer will start as replace mode if the value is zero, once |
|
|
cursor is moved or content is changed, disable replace mode. |
|
|
""" |
|
|
if self.buffer_replace: |
|
|
self.buffer_replace = False |
|
|
self.focus_buffer.text = event.key_sequence[0].data |
|
|
self.focus_buffer.cursor_position += 1 |
|
|
else: |
|
|
self.focus_buffer.insert_text(event.key_sequence[0].data) |
|
|
|
|
|
def _handle_negative_toggle(self, _) -> None: |
|
|
"""Toggle negativity of the prompt value. |
|
|
|
|
|
Force the `-` sign at the start. |
|
|
""" |
|
|
if self._whole_buffer.text == "-": |
|
|
self._whole_buffer.text = "0" |
|
|
return |
|
|
if self._whole_buffer.text.startswith("-"): |
|
|
move_cursor = self._whole_buffer.cursor_position < len( |
|
|
self._whole_buffer.text |
|
|
) |
|
|
self._whole_buffer.text = self._whole_buffer.text[1:] |
|
|
if move_cursor: |
|
|
self._whole_buffer.cursor_position -= 1 |
|
|
else: |
|
|
move_cursor = self._whole_buffer.cursor_position != 0 |
|
|
self._whole_buffer.text = f"-{self._whole_buffer.text}" |
|
|
if move_cursor: |
|
|
self._whole_buffer.cursor_position += 1 |
|
|
|
|
|
def _on_whole_text_change(self, buffer: Buffer) -> None: |
|
|
"""Handle event of text changes in buffer.""" |
|
|
self._whole_width = len(buffer.text) + 1 |
|
|
self._on_text_change(buffer) |
|
|
|
|
|
def _on_integral_text_change(self, buffer: Buffer) -> None: |
|
|
"""Handle event of text changes in buffer.""" |
|
|
self._integral_width = len(buffer.text) + 1 |
|
|
self._on_text_change(buffer) |
|
|
|
|
|
def _on_text_change(self, buffer: Buffer) -> None: |
|
|
"""Disable replace mode and fix cursor position on text changes.""" |
|
|
self.buffer_replace = False |
|
|
if buffer.text and buffer.text != "-": |
|
|
self.value = self.value |
|
|
if buffer.text.startswith("-") and buffer.cursor_position == 0: |
|
|
buffer.cursor_position = 1 |
|
|
|
|
|
def _on_cursor_position_change(self, buffer: Buffer) -> None: |
|
|
"""Fix cursor position on cursor movement.""" |
|
|
if self.focus_buffer.text.startswith("-") and buffer.cursor_position == 0: |
|
|
buffer.cursor_position = 1 |
|
|
|
|
|
@property |
|
|
def buffer_replace(self) -> bool: |
|
|
"""bool: Current buffer replace mode.""" |
|
|
if self.focus_buffer == self._whole_buffer: |
|
|
return self._whole_replace |
|
|
else: |
|
|
return self._integral_replace |
|
|
|
|
|
@buffer_replace.setter |
|
|
def buffer_replace(self, value) -> None: |
|
|
if self.focus_buffer == self._whole_buffer: |
|
|
self._whole_replace = value |
|
|
else: |
|
|
self._integral_replace = value |
|
|
|
|
|
@property |
|
|
def focus_buffer(self) -> Buffer: |
|
|
"""Buffer: Current editable buffer.""" |
|
|
if self.focus == self._whole_window: |
|
|
return self._whole_buffer |
|
|
else: |
|
|
return self._integral_buffer |
|
|
|
|
|
@property |
|
|
def focus(self) -> Window: |
|
|
"""Window: Current focused window.""" |
|
|
return self._focus |
|
|
|
|
|
@focus.setter |
|
|
def focus(self, value: Window) -> None: |
|
|
self._focus = value |
|
|
self._layout.focus(self._focus) |
|
|
|
|
|
@property |
|
|
def value(self) -> Union[int, float, Decimal]: |
|
|
"""Union[int, float]: The actual value of the prompt, combining and transforming all input buffer values.""" |
|
|
try: |
|
|
if not self._float: |
|
|
return int(self._whole_buffer.text) |
|
|
else: |
|
|
return Decimal( |
|
|
f"{self._whole_buffer.text}.{self._integral_buffer.text if self._integral_buffer.text else 0}" |
|
|
) |
|
|
except ValueError: |
|
|
self._set_error(self._value_error_message) |
|
|
return self._default |
|
|
|
|
|
@value.setter |
|
|
def value(self, value: Union[int, float, Decimal]) -> None: |
|
|
if self._min is not None: |
|
|
value = max( |
|
|
value, self._min if not self._float else Decimal(str(self._min)) |
|
|
) |
|
|
if self._max is not None: |
|
|
value = min( |
|
|
value, self._max if not self._float else Decimal(str(self._max)) |
|
|
) |
|
|
if not self._float: |
|
|
self._whole_buffer.text = str(value) |
|
|
else: |
|
|
if self._sn_pattern.match(str(value)) is None: |
|
|
whole_buffer_text, integral_buffer_text = str(value).split(".") |
|
|
else: |
|
|
whole_buffer_text, integral_buffer_text = self._fix_sn(str(value)) |
|
|
|
|
|
if self._whole_buffer.text: |
|
|
self._whole_buffer.text = whole_buffer_text |
|
|
if self._integral_buffer.text: |
|
|
self._integral_buffer.text = integral_buffer_text |
|
|
|
