ask-shell 0.10.2__tar.gz → 0.11.0__tar.gz

{ask_shell-0.10.2 → ask_shell-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ask-shell
-Version: 0.10.2
+Version: 0.11.0
 Summary: CLIs with prompts, shell runs, and testable flows
 Author-email: EspenAlbert <espen.albert1@gmail.com>
 License-Expression: MIT

{ask_shell-0.10.2 → ask_shell-0.11.0}/ask_shell/__init__.py

@@ -3,16 +3,16 @@
 from ask_shell import shell
 from ask_shell import console
 from ask_shell import shell_events
-from ask_shell import ask
 from ask_shell.settings import AskShellSettings
 from ask_shell.settings import ShellRunSummary
+from ask_shell import ask
 
-VERSION = "0.10.2"
+VERSION = "0.11.0"
 __all__ = [
     "shell",
     "console",
     "shell_events",
-    "ask",
     "AskShellSettings",
     "ShellRunSummary",
+    "ask",
 ]

{ask_shell-0.10.2 → ask_shell-0.11.0}/ask_shell/_internal/_run.py

@@ -278,16 +278,13 @@ def _run(
     output_dir: Path,
     file_name: str,
 ) -> None:
-    kwargs = (
-        dict(
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            start_new_session=True,
-            universal_newlines=True,
-        )
-        | config.popen_kwargs
-    )
-    with subprocess.Popen(config.shell_input, shell=True, **kwargs) as proc:  # type: ignore
+    kwargs = {
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "start_new_session": True,
+        "universal_newlines": True,
+    } | config.popen_kwargs
+    with subprocess.Popen(config.shell_input, shell=True, **kwargs) as proc:
         queue.put_nowait(ShellRunPOpenStarted(proc))
 
         def stdout_started(is_stdout: bool, console: Console, log_path: Path):
@@ -310,7 +307,7 @@ def _run(
                     is_stdout=True,
                 )
             except BaseException as e:
-                logger.exception(e)
+                logger.exception("stdout read failed")
                 queue.put_nowait(ShellRunStdReadError(is_stdout=True, error=e))
 
         def add_stderr_line(line: str):
@@ -330,7 +327,7 @@ def _run(
                     is_stdout=False,
                 )
             except BaseException as e:
-                logger.exception(e)
+                logger.exception("stderr read failed")
                 queue.put_nowait(ShellRunStdReadError(is_stdout=False, error=e))
 
         fut_stdout = _pool.submit(read_stdout)
@@ -357,7 +354,7 @@ def _attempt_run(
         return shell_run
     except BaseException as e:
         logger.warning(f"Error running {shell_run}: {e!r}")
-        logger.exception(e)
+        logger.exception("run failed")
         return e
     finally:
         _runs.pop(key, None)
@@ -369,7 +366,7 @@ def _eval_should_retry(config: ShellConfig, result: ShellRun) -> bool:
         return config.should_retry(result)
     except AbortRetryError:
         raise
-    except Exception as e:
+    except (TypeError, ValueError, RuntimeError, OSError, AttributeError) as e:
         logger.warning(f"should_retry callback failed: {e!r}")
         return False
 
@@ -423,13 +420,13 @@ def _execute_run(shell_run: ShellRun) -> ShellRun:
                 ctx.run(shell_run._on_event, message)
             except BaseException as e:
                 logger.warning(f"Error processing message '{type(message).__name__}' for {shell_run}: {e!r}")
-                logger.exception(e)
+                logger.exception("message callback failed")
 
     try:
         shell_run._on_event(
             ShellRunBefore(run=shell_run)
         )  # can block, for example if the thread pool doesn't have enough threads free
-    except BaseException as e:
+    except BaseException as e:  # noqa: BLE001
         logger.warning(f"Error before starting run {shell_run}: {e!r}")
         shell_run._complete(error=e)
         return shell_run
@@ -466,7 +463,7 @@ def run(
     retry_jitter: float | None = None,
     retry_max_wait: float | None = None,
     run_log_stem_prefix: str | None = None,
-    run_output_dir: Path | None | None = None,
+    run_output_dir: Path | None = None,
     settings: AskShellSettings | None = None,
     should_retry: Callable[[ShellRun], bool] | None = None,
     skip_binary_check: bool | None = None,
@@ -533,7 +530,7 @@ def run_and_wait(
     retry_jitter: float | None = None,
     retry_max_wait: float | None = None,
     run_log_stem_prefix: str | None = None,
-    run_output_dir: Path | None | None = None,
+    run_output_dir: Path | None = None,
     settings: AskShellSettings | None = None,
     should_retry: Callable[[ShellRun], bool] | None = None,
     skip_binary_check: bool | None = None,
@@ -586,7 +583,9 @@ def run_and_wait(
 def run_error(run: ShellRun, timeout: float | None = 1) -> BaseException | None:
     try:
         run._complete_flag.result(timeout=timeout)
-    except BaseException as e:
+    except TimeoutError as e:
+        return e
+    except Exception as e:  # noqa: BLE001
         return e
 
 

{ask_shell-0.10.2 → ask_shell-0.11.0}/ask_shell/_internal/interactive.py

@@ -1,5 +1,3 @@
-"""Inspired by: https://github.com/tmbo/questionary/blob/master/tests/utils.py"""
-
 from __future__ import annotations
 
 import asyncio
@@ -7,25 +5,31 @@ import io
 import logging
 import os
 import string
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
-from functools import wraps
-from typing import Any, Callable, Generic, Self, TypeVar
+from typing import Any, Generic, Self, TypeVar
 
 from prompt_toolkit.input.defaults import create_pipe_input
 from prompt_toolkit.output import DummyOutput
 from prompt_toolkit.output.plain_text import PlainTextOutput
 from pydantic import BaseModel, model_validator
-from questionary import Choice, Question, checkbox
+from questionary import Question, checkbox
 from questionary import confirm as _confirm
 from questionary import select as _select
 from questionary import text as _text
-from zero_3rdparty.object_name import as_name, func_arg_names
+from zero_3rdparty.object_name import as_name
 from zero_3rdparty.str_utils import ensure_suffix
 
 from ask_shell._internal._run import get_pool
 from ask_shell._internal._run_env import (
     interactive_shell,
 )
+from ask_shell._internal.interactive_models import ChoiceTyped, PromptKind
+from ask_shell._internal.non_interactive import (
+    record_answered_row,
+    replay_or_dump,
+    try_replay_answered,
+)
 from ask_shell._internal.rich_live import pause_live
 from ask_shell.settings import AskShellSettings, _global_settings
 
@@ -48,29 +52,6 @@ def _default_asker(q: Question, _: type[T]) -> T:
 _question_asker: TypedAsk = _default_asker
 
 
-FuncT = TypeVar("FuncT", bound=Callable)
-
-
-def return_default_if_not_interactive(func: FuncT) -> FuncT:
-    assert "default" in func_arg_names(func), f"Function {as_name(func)} must have a 'default' parameter"
-
-    @wraps(func)
-    def return_default(*args, **kwargs):
-        if interactive_shell():
-            return func(*args, **kwargs)
-        default_value = kwargs.get("default", None)
-        if default_value is None:
-            raise ValueError(
-                f"Function called in non-interactive shell, but no default value provided &func={as_name(func)}"
-            )
-        logger.warning(
-            f"Function {as_name(func)} called in non-interactive shell, returning default value: {default_value}"
-        )
-        return default_value
-
-    return return_default  # type: ignore
-
-
 _PROMPT_TEXT_ATTR_NAME = "__prompt_text__"
 
 
@@ -78,16 +59,6 @@ def _set_prompt_text(q: Question, prompt_text: str) -> None:
     setattr(q, _PROMPT_TEXT_ATTR_NAME, prompt_text)
 
 
-@pause_live
-def confirm(prompt_text: str, *, default: bool | None = None) -> bool:
-    if default is None:
-        question = _confirm(prompt_text)
-    else:
-        question = _confirm(prompt_text, default=default)
-    _set_prompt_text(question, prompt_text)
-    return _question_asker(question, bool)
-
-
 _unset = object()
 
 
@@ -103,38 +74,78 @@ class NewHandlerChoice(Generic[T]):
     new_prompt: str
 
 
-@dataclass
-class ChoiceTyped(Generic[T]):
-    name: str
-    value: T
-    description: str | None = None
-    checked: bool = False
-
-    @classmethod
-    def from_descriptions(cls, descriptions: dict[str, str]) -> list[ChoiceTyped[str]]:
-        return [
-            cls(name=name, value=name, description=description)  # type: ignore
-            for name, description in descriptions.items()
-        ]  # type: ignore
-
-    def as_choice(self) -> Choice:
-        return Choice(
-            title=self.name,
-            value=self.value,
-            description=self.description,
-            checked=self.checked,
-        )
+def _ask_with_session(
+    *,
+    kind: PromptKind,
+    prompt: str,
+    choices: Sequence[ChoiceTyped],
+    has_usable_default: bool,
+    usable_default: Any,
+    ask_fn: Callable[[], T],
+) -> T:
+    if _question_asker is not _default_asker:
+        return ask_fn()
+    settings = AskShellSettings.from_env()
+    if not interactive_shell():
+        if settings.use_defaults and has_usable_default:
+            logger.warning(f"Ask called in non-interactive shell, returning default value: {usable_default}")
+            record_answered_row(
+                kind=kind,
+                prompt=prompt,
+                settings=settings,
+                choices=choices,
+                value=usable_default,
+            )
+            return usable_default
+        return replay_or_dump(kind=kind, prompt=prompt, settings=settings, choices=choices)
+    replayed = try_replay_answered(kind=kind, prompt=prompt, settings=settings, choices=choices)
+    if replayed is not None:
+        return replayed
+    value = ask_fn()
+    record_answered_row(kind=kind, prompt=prompt, settings=settings, choices=choices, value=value)
+    return value
+
+
+@pause_live
+def confirm(prompt_text: str, *, default: bool | None = None) -> bool:
+    def ask_fn() -> bool:
+        if default is None:
+            question = _confirm(prompt_text)
+        else:
+            question = _confirm(prompt_text, default=default)
+        _set_prompt_text(question, prompt_text)
+        return _question_asker(question, bool)
+
+    return _ask_with_session(
+        kind=PromptKind.CONFIRM,
+        prompt=prompt_text,
+        choices=(),
+        has_usable_default=default is not None,
+        usable_default=default,
+        ask_fn=ask_fn,
+    )
 
 
 @pause_live
-@return_default_if_not_interactive
 def text(
     prompt_text: str,
-    default: str = "",
+    default: str | None = None,
 ) -> str:
-    question = _text(prompt_text, default=default)
-    _set_prompt_text(question, prompt_text)
-    return _question_asker(question, str)
+    questionary_default = default if default is not None else ""
+
+    def ask_fn() -> str:
+        question = _text(prompt_text, default=questionary_default)
+        _set_prompt_text(question, prompt_text)
+        return _question_asker(question, str)
+
+    return _ask_with_session(
+        kind=PromptKind.TEXT,
+        prompt=prompt_text,
+        choices=(),
+        has_usable_default=default is not None,
+        usable_default=default,
+        ask_fn=ask_fn,
+    )
 
 
 class SelectOptions(BaseModel, Generic[T]):
@@ -194,7 +205,7 @@ class SelectOptions(BaseModel, Generic[T]):
         )
         _set_prompt_text(question, prompt_text)
         try:
-            return _question_asker(question, T)
+            return _question_asker(question, T)  # ty: ignore[invalid-argument-type]
         except KeyboardInterrupt:
             if not self.allow_new:
                 raise
@@ -228,7 +239,6 @@ class SelectOptions(BaseModel, Generic[T]):
 
 
 @pause_live
-@return_default_if_not_interactive
 def select_list_multiple(
     prompt_text: str,
     choices: list[str],
@@ -238,13 +248,23 @@ def select_list_multiple(
 ) -> list[str]:
     assert choices, f"choices must not be empty for {as_name(select_list_multiple)}"
     options = options or SelectOptions()
-    default = default or []
-    default_choices = [ChoiceTyped(option, checked=option in default, value=option) for option in choices]
-    return options._select_multiple(prompt_text, default_choices)
+    default_checked = default or []
+    typed_choices = [ChoiceTyped(option, checked=option in default_checked, value=option) for option in choices]
+
+    def ask_fn() -> list[str]:
+        return options._select_multiple(prompt_text, typed_choices)
+
+    return _ask_with_session(
+        kind=PromptKind.SELECT_MULTIPLE,
+        prompt=prompt_text,
+        choices=typed_choices,
+        has_usable_default=default is not None,
+        usable_default=default_checked,
+        ask_fn=ask_fn,
+    )
 
 
 @pause_live
-@return_default_if_not_interactive
 def select_list_multiple_choices(
     prompt_text: str,
     choices: list[ChoiceTyped[T]],
@@ -255,11 +275,21 @@ def select_list_multiple_choices(
 ) -> list[T]:
     assert choices, f"choices must not be empty for {as_name(select_list_multiple_choices)}"
     options = options or SelectOptions()
-    return options._select_multiple(prompt_text, choices)
+
+    def ask_fn() -> list[T]:
+        return options._select_multiple(prompt_text, choices)
+
+    return _ask_with_session(
+        kind=PromptKind.SELECT_MULTIPLE,
+        prompt=prompt_text,
+        choices=choices,
+        has_usable_default=default is not None,
+        usable_default=default or [],
+        ask_fn=ask_fn,
+    )
 
 
 @pause_live
-@return_default_if_not_interactive
 def select_dict(
     prompt_text: str,
     choices: dict[str, T],
@@ -270,12 +300,23 @@ def select_dict(
     assert choices, f"choices must not be empty for {as_name(select_dict)}"
     options = options or SelectOptions()
     default_safe = default or ""
-    choices_typed = [ChoiceTyped(name=key, value=value, checked=key == default_safe) for key, value in choices.items()]
-    return options._select(prompt_text, choices_typed)
+    typed_choices = [ChoiceTyped(name=key, value=value, checked=key == default_safe) for key, value in choices.items()]
+    default_in_choices = default in choices if default is not None else False
+
+    def ask_fn() -> T:
+        return options._select(prompt_text, typed_choices)
+
+    return _ask_with_session(
+        kind=PromptKind.SELECT,
+        prompt=prompt_text,
+        choices=typed_choices,
+        has_usable_default=default_in_choices,
+        usable_default=choices[default] if default is not None and default in choices else None,
+        ask_fn=ask_fn,
+    )
 
 
 @pause_live
-@return_default_if_not_interactive
 def select_list(
     prompt_text: str,
     choices: list[str],
@@ -285,22 +326,34 @@ def select_list(
 ) -> str:
     assert choices, f"choices must not be empty for {as_name(select_list)}"
     options = options or SelectOptions()
-    chosen = options.set_defaults(len(choices))
-    return _question_asker(
-        _select(
-            prompt_text,
-            default=default,
-            choices=choices,
-            use_jk_keys=chosen.use_jk_keys,
-            use_shortcuts=chosen.use_shortcuts,
-            use_search_filter=chosen.use_search_filter,
-        ),
-        str,
+    typed_choices = [ChoiceTyped(name=choice, value=choice) for choice in choices]
+    default_in_choices = default in choices if default is not None else False
+
+    def ask_fn() -> str:
+        chosen = options.set_defaults(len(choices))
+        return _question_asker(
+            _select(
+                prompt_text,
+                default=default,
+                choices=choices,
+                use_jk_keys=chosen.use_jk_keys,
+                use_shortcuts=chosen.use_shortcuts,
+                use_search_filter=chosen.use_search_filter,
+            ),
+            str,
+        )
+
+    return _ask_with_session(
+        kind=PromptKind.SELECT,
+        prompt=prompt_text,
+        choices=typed_choices,
+        has_usable_default=default_in_choices,
+        usable_default=default if default_in_choices else None,
+        ask_fn=ask_fn,
     )
 
 
 @pause_live
-@return_default_if_not_interactive
 def select_list_choice(
     prompt_text: str,
     choices: list[ChoiceTyped[T]],
@@ -310,7 +363,20 @@ def select_list_choice(
 ) -> T:
     assert choices, f"choices must not be empty for {as_name(select_list_choice)}"
     options = options or SelectOptions()
-    return options._select(prompt_text, choices)
+    choice_values = {choice.value for choice in choices}
+    default_in_choices = default is not None and default in choice_values
+
+    def ask_fn() -> T:
+        return options._select(prompt_text, choices)
+
+    return _ask_with_session(
+        kind=PromptKind.SELECT,
+        prompt=prompt_text,
+        choices=choices,
+        has_usable_default=default_in_choices,
+        usable_default=default if default_in_choices else None,
+        ask_fn=ask_fn,
+    )
 
 
 class KeyInput:
@@ -365,9 +431,7 @@ class PromptMatch:
             return False
         if (substr := self.substring) and substr in prompt_text:
             return True
-        if (exact := self.exact) and exact == prompt_text:
-            return True
-        return False
+        return bool((exact := self.exact) and exact == prompt_text)
 
     def __eq__(self, value: object) -> bool:
         if not isinstance(value, PromptMatch):

ask_shell-0.11.0/ask_shell/_internal/interactive_models.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Annotated, Generic, Literal, TypeVar
+
+from model_lib import Entity
+from pydantic import Field
+from questionary import Choice
+
+_UNDECIDED = "undecided"
+
+T = TypeVar("T")
+
+
+class PromptKind(StrEnum):
+    CONFIRM = "confirm"
+    TEXT = "text"
+    SELECT = "select"
+    SELECT_MULTIPLE = "select_multiple"
+
+
+class MultiSelectStatus(StrEnum):
+    UNDECIDED = "undecided"
+    ANSWERED = "answered"
+
+
+class SelectAlternative(Entity):
+    name: str
+    description: str | None = None
+
+
+class ConfirmQuestion(Entity):
+    kind: Literal[PromptKind.CONFIRM] = PromptKind.CONFIRM
+    prompt: str
+    response: Literal["undecided"] | bool = _UNDECIDED
+
+
+class TextQuestion(Entity):
+    kind: Literal[PromptKind.TEXT] = PromptKind.TEXT
+    prompt: str
+    response: str = _UNDECIDED
+
+
+class SelectQuestion(Entity):
+    kind: Literal[PromptKind.SELECT] = PromptKind.SELECT
+    prompt: str
+    alternatives: list[SelectAlternative] = Field(default_factory=list)
+    chosen: str | None = None
+
+
+class SelectMultipleQuestion(Entity):
+    kind: Literal[PromptKind.SELECT_MULTIPLE] = PromptKind.SELECT_MULTIPLE
+    prompt: str
+    status: MultiSelectStatus = MultiSelectStatus.UNDECIDED
+    alternatives: list[SelectAlternative] = Field(default_factory=list)
+    checked: list[str] = Field(default_factory=list)
+
+
+PromptQuestion = Annotated[
+    ConfirmQuestion | TextQuestion | SelectQuestion | SelectMultipleQuestion,
+    Field(discriminator="kind"),
+]
+
+
+class NonInteractivePromptFile(Entity):
+    questions: list[PromptQuestion] = Field(default_factory=list)
+
+
+@dataclass
+class ChoiceTyped(Generic[T]):
+    name: str
+    value: T
+    description: str | None = None
+    checked: bool = False
+
+    @classmethod
+    def from_descriptions(cls, descriptions: dict[str, str]) -> list[ChoiceTyped[str]]:
+        return [cls(name=name, value=name, description=description) for name, description in descriptions.items()]  # type: ignore
+
+    def as_choice(self) -> Choice:
+        return Choice(
+            title=self.name,
+            value=self.value,
+            description=self.description,
+            checked=self.checked,
+        )

{ask_shell-0.10.2 → ask_shell-0.11.0}/ask_shell/_internal/models.py

@@ -342,9 +342,8 @@ class ShellRun:
             return False
 
         def remove_callback():
-            with self._lock:
-                with suppress(ValueError):  # if the callback was already removed
-                    self.config.message_callbacks.remove(only_on_output_callback)
+            with self._lock, suppress(ValueError):  # if the callback was already removed
+                self.config.message_callbacks.remove(only_on_output_callback)
 
         with self._lock:
             self.config.message_callbacks.append(only_on_output_callback)
@@ -362,7 +361,7 @@ class ShellRun:
             try:
                 if callback(message):
                     self.config.message_callbacks.remove(callback)
-            except Exception as e:
+            except (TypeError, ValueError, RuntimeError, OSError, AttributeError) as e:
                 logger.error(f"Error in message callback: {e!r}")
 
     def _dump_html_logs(self):
@@ -410,7 +409,7 @@ class ShellRun:
         if no_raise:
             try:
                 return self._complete_flag.result(timeout)
-            except Exception:
+            except Exception:  # noqa: BLE001
                 return self
         return self._complete_flag.result(timeout)