calkit-python 0.49.3__py3-none-any.whl → 0.49.4__py3-none-any.whl

calkit/cli/__init__.py

@@ -19,6 +19,16 @@ def run() -> None:
     # otherwise print the *current* CLI's help instead of re-execing
     # under the requested version.
     _maybe_exec_with_version()
+    if sys.platform == "win32":
+        import io
+
+        from calkit.core import is_mintty
+
+        # mintty shows UTF-8, so emoji needn't be replaced, and output is
+        # line buffered as it would be to a terminal
+        for stream in (sys.stdout, sys.stderr):
+            if isinstance(stream, io.TextIOWrapper) and is_mintty(stream):
+                stream.reconfigure(encoding="utf-8", line_buffering=True)
     from .main import app
 
     # Completion lists commands, so needs them all

calkit/cli/core.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import re
 import subprocess
+import sys
 from enum import Enum
 from typing import Any, NoReturn
 
@@ -152,8 +153,24 @@ def echo_json(obj: Any) -> None:
     typer.echo(json.dumps(obj, default=str))
 
 
+def _echo_above_spinner(text: str, err: bool) -> bool:
+    """Print through a spinner's stand-in for the stream, if there is one.
+
+    Click writes to a Windows console's handle directly, which would put the
+    text on the spinner's line rather than above it.
+    """
+    file_proxy = sys.modules.get("rich.file_proxy")
+    stream = sys.stderr if err else sys.stdout
+    if file_proxy is None or not isinstance(stream, file_proxy.FileProxy):
+        return False
+    print(text, file=stream, flush=True)
+    return True
+
+
 def raise_error(txt: str) -> NoReturn:
-    typer.echo(typer.style("Error: " + str(txt), fg="red"), err=True)
+    text = typer.style("Error: " + str(txt), fg="red")
+    if not _echo_above_spinner(text, err=True):
+        typer.echo(text, err=True)
     raise typer.Exit(1)
 
 
@@ -164,7 +181,6 @@ def warn(txt: str, prefix: str = "Warning: ", err: bool = False):
     # defined.
     from calkit.core import encode_safe
 
-    typer.echo(
-        typer.style(prefix + encode_safe(str(txt), err=err), fg="yellow"),
-        err=err,
-    )
+    text = typer.style(prefix + encode_safe(str(txt), err=err), fg="yellow")
+    if not _echo_above_spinner(text, err=err):
+        typer.echo(text, err=err)

calkit/cli/main/core.py

@@ -542,6 +542,18 @@ def get_status(
         if isinstance(spinner, Status):
             spinner.update(text)
 
+    def start_docker() -> None:
+        # Asked with the spinner out of the way, as in 'calkit run'
+        import calkit.docker
+
+        if isinstance(spinner, Status):
+            spinner.stop()
+        try:
+            calkit.docker.ensure_ready(interactive=True)
+        finally:
+            if isinstance(spinner, Status):
+                spinner.start()
+
     def get_dvc_data_status() -> dict:
         # Reuse what the pipeline status computed under the same DVC lock
         if (
@@ -624,15 +636,23 @@ def get_status(
     # while, e.g., when environments are checked again, so a spinner shows
     # until then. It writes to its own copy of the terminal, since what the
     # environment checks' tools print is discarded.
+    # Whether there's someone to ask is worked out before the spinner starts
+    can_ask = not as_json and calkit.core.is_tty()
     spinner: AbstractContextManager = nullcontext()
-    if not as_json and sys.stderr.isatty():
+    mintty = calkit.core.is_mintty(sys.stderr)
+    if not as_json and (sys.stderr.isatty() or mintty):
         import logging
 
         from rich.console import Console
 
-        spinner = Console(file=os.fdopen(os.dup(2), "w")).status(
-            "Checking status"
-        )
+        # mintty takes ANSI and UTF-8, though it isn't a console
+        spinner = Console(
+            file=os.fdopen(
+                os.dup(2), "w", encoding="utf-8" if mintty else None
+            ),
+            force_terminal=mintty or None,
+            legacy_windows=False if mintty else None,
+        ).status("Checking status")
         # DVC's progress bars would each be printed above the spinner, and
         # they're shown only if this is at or below their level
         logging.getLogger("dvc.progress").setLevel(logging.CRITICAL + 1)
@@ -665,6 +685,7 @@ def get_status(
                 with_storage_problems="dvc" in categories,
                 quiet_environment_checks=True,
                 progress=step,
+                start_docker=start_docker if can_ask else None,
             )
             if pipeline_status.failed_environment_checks:
                 warn(
@@ -3128,12 +3149,18 @@ def run(
     # someone to ask is worked out first
     can_ask = is_tty()
     spinner: Any = None
-    if not (quiet or verbose) and sys.stderr.isatty():
+    mintty = calkit.core.is_mintty(sys.stderr)
+    if not (quiet or verbose) and (sys.stderr.isatty() or mintty):
         from rich.console import Console
 
-        spinner = Console(file=os.fdopen(os.dup(2), "w")).status(
-            "Getting ready to run"
-        )
+        # mintty takes ANSI and UTF-8, though it isn't a console
+        spinner = Console(
+            file=os.fdopen(
+                os.dup(2), "w", encoding="utf-8" if mintty else None
+            ),
+            force_terminal=mintty or None,
+            legacy_windows=False if mintty else None,
+        ).status("Getting ready to run")
     with spinner or contextlib.nullcontext():
         step("Getting system information", "💻")
         # Only the stages this run can reach are checked, so nothing else
@@ -4781,7 +4808,7 @@ def install_app(
         ok = _install.prompt_and_install(name, interactive=is_tty())
     if not ok:
         raise_error(f"Failed to install '{name}'")
-    typer.echo(f"✅ Installed '{name}'")
+    calkit.echo(f"✅ Installed '{name}'")
 
 
 @app.command(name="xproc|runproc", help="Execute a procedure.")

calkit/cli/overleaf.py

@@ -62,7 +62,8 @@ def _get_overleaf_token(rejected: bool = False) -> str:
             "A new one can be generated at:\n\n"
             "    https://www.overleaf.com/user/settings\n\n"
             "under the 'Git Integration' section.\n"
-            "Without Overleaf Premium, run 'calkit overleaf login' instead.\n"
+            "Without Overleaf Premium, run 'calkit overleaf login' instead, "
+            "or connect from the Calkit browser extension on overleaf.com.\n"
         )
         if not (sys.stdin.isatty() and sys.stdout.isatty()):
             raise_error(
@@ -82,27 +83,54 @@ def _get_overleaf_token(rejected: bool = False) -> str:
     return overleaf_token
 
 
+def _get_overleaf_session_from_hub(stale: str | None = None) -> str | None:
+    """Get an Overleaf session saved to the hub, e.g., by the browser
+    extension, other than a ``stale`` one, and store it in config.
+    """
+    try:
+        # Not signed in to the hub fails before any request, and
+        # allow_login=False keeps that from starting a sign-in
+        session = calkit.hub.get(
+            "/user/overleaf-session", allow_login=False, max_retries=2
+        )["session"]
+    except Exception:
+        return None
+    # Compared as the client sends it, without a cookie name or whitespace
+    if not session or calkit.overleaf.WebClient(session).session == stale:
+        return None
+    calkit_config = calkit.config.read()
+    calkit_config.overleaf_session = session
+    calkit_config.write()
+    return str(session)
+
+
 def _get_overleaf_auth() -> str | calkit.overleaf.WebClient:
     """Get a Git token, or, if only a session is available, a web client
     for syncing without Overleaf Premium.
 
-    Credentials in config come first, then a token saved to the hub, before
-    prompting for a token.
+    Credentials in config come first, then a token saved to the hub, then a
+    session saved to the hub, before prompting for a token.
     """
     calkit_config = calkit.config.read()
     if calkit_config.overleaf_token:
         return calkit_config.overleaf_token
     if calkit_config.overleaf_session:
         return calkit.overleaf.WebClient(calkit_config.overleaf_session)
-    if calkit_config.token is not None:
-        try:
-            typer.echo("Getting Overleaf token from the hub")
-            token = calkit.hub.get("/user/overleaf-token")["access_token"]
-            calkit_config.overleaf_token = token
-            calkit_config.write()
-            return str(token)
-        except Exception:
-            typer.echo("No Overleaf token on the hub")
+    try:
+        token = calkit.hub.get(
+            "/user/overleaf-token", allow_login=False, max_retries=2
+        )["access_token"]
+    except Exception:
+        token = None
+    if token:
+        typer.echo("Using the Overleaf token saved to the hub")
+        calkit_config.overleaf_token = token
+        calkit_config.write()
+        return str(token)
+    session = _get_overleaf_session_from_hub()
+    if session:
+        typer.echo("Using the Overleaf session saved to the hub")
+        return calkit.overleaf.WebClient(session)
     return _get_overleaf_token()
 
 
@@ -116,9 +144,16 @@ def _get_pulled_overleaf_repo(
     them too.
     """
 
-    def get_new_session() -> str:
-        """Prompt for a new Overleaf session and store it."""
-        warn("Overleaf rejected your session", prefix="")
+    def get_new_session(stale: str, error: Exception) -> str:
+        """Get a new Overleaf session from the hub, or prompt for one, and
+        store it.
+        """
+        # A newer session on the hub, e.g., from the browser extension,
+        # means nothing failed as far as the user is concerned
+        session = _get_overleaf_session_from_hub(stale=stale)
+        if session:
+            return session
+        warn(str(error), prefix="")
         typer.echo(calkit.overleaf.SESSION_HELP + "\n")
         if not (sys.stdin.isatty() and sys.stdout.isatty()):
             raise_error(
@@ -145,18 +180,28 @@ def _get_pulled_overleaf_repo(
             return repo, auth
         except calkit.overleaf.AuthError as e:
             if isinstance(auth, calkit.overleaf.WebClient):
-                warn(str(e), prefix="")
-                auth = calkit.overleaf.WebClient(get_new_session())
+                auth = calkit.overleaf.WebClient(
+                    get_new_session(stale=auth.session, error=e)
+                )
             else:
                 # A token stops working when Premium ends, but a browser
                 # session still does
-                session = calkit.config.read().overleaf_session
+                session = (
+                    calkit.config.read().overleaf_session
+                    or _get_overleaf_session_from_hub()
+                )
                 if session:
                     warn(
                         "Overleaf rejected your Git token; "
                         "using your browser session instead",
                         prefix="",
                     )
+                    # Forget the token, so later syncs go straight to the
+                    # session
+                    calkit_config = calkit.config.read()
+                    if calkit_config.overleaf_token == auth:
+                        calkit_config.overleaf_token = None
+                        calkit_config.write()
                     auth = calkit.overleaf.WebClient(str(session))
                 else:
                     auth = _get_overleaf_token(rejected=True)
@@ -173,6 +218,13 @@ def login(
             help="Value of the 'overleaf_session2' cookie from your browser.",
         ),
     ] = None,
+    hub: Annotated[
+        bool,
+        typer.Option(
+            "--hub",
+            help="Also save session to Calkit hub, so it can sync there.",
+        ),
+    ] = False,
 ) -> None:
     """Sign in with a browser session to sync without Overleaf Premium."""
     if session is None:
@@ -190,6 +242,12 @@ def login(
     )
     calkit_config.write()
     typer.echo("Stored Overleaf session in Calkit config")
+    if hub:
+        try:
+            calkit.hub.put("/user/overleaf-session", json={"session": session})
+        except Exception as e:
+            raise_error(f"Failed to save Overleaf session to hub: {e}")
+        typer.echo("Saved Overleaf session to hub")
     if calkit_config.overleaf_token:
         warn(
             "An Overleaf Git token is also set and will be used instead; "
@@ -708,6 +766,16 @@ def sync(
             help="When rebuilding, also run stages the build depends on.",
         ),
     ] = False,
+    no_pull: Annotated[
+        bool,
+        typer.Option(
+            "--no-pull",
+            help=(
+                "Don't pull new commits from the project remote first, "
+                "e.g., from a sync on the hub."
+            ),
+        ),
+    ] = False,
 ):
     """Sync folders with Overleaf.
 
@@ -752,6 +820,52 @@ def sync(
         return {path: (content.get(path), u) for path, u in untracked.items()}
 
     repo = calkit.git.get_repo()
+    in_am_session = "in the middle of an am session" in repo.git.status()
+    # A sync on the hub or another machine pushes commits here, and syncing
+    # without them would apply the same Overleaf edits again. Pulled before
+    # reading the sync settings, since the new commits can change them.
+    if not no_pull and not resolve and not in_am_session:
+        import git
+
+        try:
+            tracking = repo.active_branch.tracking_branch()
+        except TypeError:
+            # Detached HEAD
+            tracking = None
+        fetched = False
+        if tracking is not None:
+            try:
+                repo.git.fetch(tracking.remote_name, tracking.remote_head)
+                fetched = True
+            except git.GitCommandError:
+                warn(
+                    f"Could not fetch {tracking.name}; "
+                    "syncing without any new commits there"
+                )
+        if tracking is not None and fetched:
+            behind = int(
+                repo.git.rev_list("--count", f"HEAD..{tracking.name}")
+            )
+            merge_head = os.path.join(repo.git_dir, "MERGE_HEAD")
+            if behind and os.path.exists(merge_head):
+                raise_error(
+                    f"There are new commits on {tracking.name}, but a merge "
+                    "is in progress; finish it, then sync again"
+                )
+            if behind:
+                typer.echo(
+                    f"Pulling {behind} new commit(s) from {tracking.name}"
+                )
+                try:
+                    repo.git.merge("--no-edit", tracking.name)
+                except git.GitCommandError as e:
+                    if os.path.exists(merge_head):
+                        repo.git.merge("--abort")
+                    raise_error(
+                        f"Could not pull new commits from {tracking.name}:\n"
+                        + str(e.stderr).strip()
+                        + "\nPull them yourself, then sync again"
+                    )
     # Uncommitted edits to calkit.yaml aren't the sync's to touch or commit,
     # so fixing the legacy schema waits until there are none
     calkit_yaml_dirty = bool(repo.git.diff("HEAD", "--", "calkit.yaml"))
@@ -799,7 +913,6 @@ def sync(
         )
     overleaf_auth = _get_overleaf_auth()
     conflict_fpath = calkit.overleaf.get_conflict_fpath()
-    in_am_session = "in the middle of an am session" in repo.git.status()
     # Check if we're in the middle of resolving a merge conflict
     if in_am_session and not resolve:
         raise_error(
@@ -1337,6 +1450,8 @@ def push_to_overleaf(
         allow_stale=True,
         any_branch=True,
         force=force,
+        # Pulling is part of preparing, or was skipped with --no-pull
+        no_pull=True,
     )
     calkit.echo("Overleaf is up-to-date with this project ✅")
 
@@ -1448,6 +1563,8 @@ def pull_from_overleaf(
         any_branch=True,
         force=force,
         no_build=no_run,
+        # Pulling is part of preparing, or was skipped with --no-pull
+        no_pull=True,
     )
     # An Overleaf edit to a map-paths copy lands in the file it's copied
     # from, so the document is only rebuilt from it after a run

calkit/cli/update.py

@@ -2212,7 +2212,7 @@ def update_hub(
             typer.echo("Committing changes")
             repo.git.commit(to_commit + ["-m", f"Connect to {hub_url}"])
         _adopt_hub_history(repo)
-    typer.echo(f"✅ Connected; project is at {hub_url}/{owner}/{name}")
+    calkit.echo(f"✅ Connected; project is at {hub_url}/{owner}/{name}")
 
 
 @update_app.command(name="comment")

calkit/core.py

@@ -778,6 +778,55 @@ def is_tty() -> bool:
         return False
 
 
+def is_mintty(stream: Any) -> bool:
+    """True when a stream is a Git Bash or Cygwin (mintty) terminal.
+
+    mintty gives native programs a named pipe rather than a console, so
+    Python sees no terminal and picks the ANSI code page, even though
+    mintty shows UTF-8 and ANSI escapes. It's told apart by the pipe's
+    name, as Git for Windows does.
+    """
+    if sys.platform != "win32":
+        return False
+    import ctypes
+    import msvcrt
+    from ctypes import wintypes
+
+    class FileNameInfo(ctypes.Structure):
+        _fields_ = [
+            ("FileNameLength", wintypes.DWORD),
+            ("FileName", wintypes.WCHAR * 260),
+        ]
+
+    try:
+        handle = msvcrt.get_osfhandle(stream.fileno())
+    except (AttributeError, OSError, ValueError):
+        return False
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.GetFileType.argtypes = [wintypes.HANDLE]
+    kernel32.GetFileInformationByHandleEx.argtypes = [
+        wintypes.HANDLE,
+        ctypes.c_int,
+        ctypes.c_void_p,
+        wintypes.DWORD,
+    ]
+    kernel32.GetFileInformationByHandleEx.restype = wintypes.BOOL
+    # FILE_TYPE_PIPE
+    if kernel32.GetFileType(handle) != 3:
+        return False
+    info = FileNameInfo()
+    # FileNameInfo
+    if not kernel32.GetFileInformationByHandleEx(
+        handle, 2, ctypes.byref(info), ctypes.sizeof(info)
+    ):
+        return False
+    name = info.FileName[: info.FileNameLength // 2]
+    return (
+        re.match(r"\\(cygwin|msys)-[0-9a-f]+-pty\d+-(from|to)-master", name)
+        is not None
+    )
+
+
 def check_dep_exists(
     name: str,
     kind: Literal["app", "env-var", "calkit-config"] = "app",

calkit/environments.py

@@ -2236,31 +2236,61 @@ def check_all_in_pipeline(
 
     @contextmanager
     def silenced() -> Iterator[None]:
-        # Tools write to the terminal directly, so this is done at the file
-        # descriptor level as well as Python's
+        # Tools write to the terminal directly, so this is done where they
+        # inherit it from as well as Python's. Nobody can see a prompt here,
+        # so input is from devnull, which answers one rather than hangs.
         if not quiet:
             yield
             return
         sys.stdout.flush()
         sys.stderr.flush()
-        saved = [os.dup(1), os.dup(2)]
-        devnull = os.open(os.devnull, os.O_WRONLY)
-        try:
-            os.dup2(devnull, 1)
-            os.dup2(devnull, 2)
-            with (
-                open(os.devnull, "w") as null,
-                redirect_stdout(null),
-                redirect_stderr(null),
-            ):
-                yield
-        finally:
-            sys.stdout.flush()
-            sys.stderr.flush()
-            os.dup2(saved[0], 1)
-            os.dup2(saved[1], 2)
-            for fd in [*saved, devnull]:
-                os.close(fd)
+        saved_stdin = sys.stdin
+        with (
+            open(os.devnull, "r+") as null,
+            redirect_stdout(null),
+            redirect_stderr(null),
+        ):
+            sys.stdin = null
+            try:
+                if sys.platform == "win32":
+                    # Replacing descriptors 0-2 would close the console
+                    # handles Click uses, so only the standard handles that
+                    # subprocesses inherit are swapped
+                    import ctypes
+                    import msvcrt
+                    from ctypes import wintypes
+
+                    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+                    kernel32.GetStdHandle.argtypes = [wintypes.DWORD]
+                    kernel32.GetStdHandle.restype = wintypes.HANDLE
+                    kernel32.SetStdHandle.argtypes = [
+                        wintypes.DWORD,
+                        wintypes.HANDLE,
+                    ]
+                    kernel32.SetStdHandle.restype = wintypes.BOOL
+                    # STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
+                    std_ids = [-10, -11, -12]
+                    null_handle = msvcrt.get_osfhandle(null.fileno())
+                    saved = [kernel32.GetStdHandle(i) for i in std_ids]
+                    try:
+                        for i in std_ids:
+                            kernel32.SetStdHandle(i, null_handle)
+                        yield
+                    finally:
+                        for i, h in zip(std_ids, saved):
+                            kernel32.SetStdHandle(i, h)
+                else:
+                    saved = [os.dup(fd) for fd in (0, 1, 2)]
+                    try:
+                        for fd in (0, 1, 2):
+                            os.dup2(null.fileno(), fd)
+                        yield
+                    finally:
+                        for fd, saved_fd in enumerate(saved):
+                            os.dup2(saved_fd, fd)
+                            os.close(saved_fd)
+            finally:
+                sys.stdin = saved_stdin
 
     # TODO: ``check_environment`` should be able to take a wdir argument
     if wdir is not None:

calkit/hub.py

@@ -143,7 +143,9 @@ def run_device_flow() -> str:
                     raise DeviceLoginError(
                         f"Failed to save token in config: {e}"
                     ) from e
-                print("Logged in successfully ✅", flush=True)
+                from calkit.core import encode_safe
+
+                print(encode_safe("Logged in successfully ✅"), flush=True)
                 return access_token
             sleep_seconds = min(
                 interval, max(0.0, deadline - time.monotonic())

calkit/models/pipeline.py

@@ -2537,6 +2537,11 @@ class MarkdownStage(Stage):
     def markdown_path(self) -> str:
         return Path(self.target_path).as_posix()
 
+    @property
+    def dvc_outs(self) -> list[str | dict]:
+        # The outputs belong to the stages the file expands into
+        return []
+
 
 class Pipeline(Model):
     """The project's reproducible pipeline."""

calkit/overleaf.py

@@ -225,7 +225,8 @@ SESSION_HELP = (
 SESSION_REJECTED_ADVICE = (
     "Your Overleaf session may have expired, e.g., by signing out of "
     "overleaf.com, or you may not have edit access to this project. "
-    "Sign in again with 'calkit overleaf login'."
+    "Sign in again with 'calkit overleaf login', or reconnect from the "
+    "Calkit browser extension on overleaf.com."
 )
 
 

calkit/pipeline.py

@@ -1223,6 +1223,7 @@ def get_status(
     with_storage_problems: bool = False,
     quiet_environment_checks: bool = False,
     progress: Callable[[str], None] | None = None,
+    start_docker: Callable[[], None] | None = None,
 ) -> PipelineStatus:
     """Get pipeline status after optional prep checks.
 
@@ -1231,12 +1232,27 @@ def get_status(
     With ``with_data_status``, DVC's data status is attached as well, left
     None if it fails so the caller can ask again and report why.
     ``progress`` is told what's being done as each step starts.
+    ``start_docker`` is called when a stage needs Docker and it isn't
+    ready, e.g., to offer to start it, and raises ``DockerNotReadyError``
+    if it still isn't.
     """
 
     def step(text: str) -> None:
         if progress is not None:
             progress(text)
 
+    def check_envs(docker_required: bool) -> dict:
+        return calkit.environments.check_all_in_pipeline(
+            ck_info=ck_info,
+            targets=targets,
+            force=force_env_check,
+            skip_stages=list(result["gated_stages"]),
+            quiet=quiet_environment_checks,
+            progress=progress,
+            docker_required=docker_required,
+        )
+
+    import calkit.docker
     import calkit.environments
     import calkit.markdown
 
@@ -1300,14 +1316,20 @@ def get_status(
                     remote=False,
                 )
                 result["gated_stages"] = gated | gate_errors
-                env_checks = calkit.environments.check_all_in_pipeline(
-                    ck_info=ck_info,
-                    targets=targets,
-                    force=force_env_check,
-                    skip_stages=list(result["gated_stages"]),
-                    quiet=quiet_environment_checks,
-                    progress=progress,
-                )
+
+                try:
+                    env_checks = check_envs(docker_required=True)
+                except calkit.docker.DockerNotReadyError:
+                    # Docker not running doesn't make anything stale, so
+                    # without it only the environments that need it fail
+                    ready = False
+                    if start_docker is not None:
+                        try:
+                            start_docker()
+                            ready = True
+                        except calkit.docker.DockerNotReadyError:
+                            pass
+                    env_checks = check_envs(docker_required=ready)
                 result["environment_checks"] = env_checks
             except Exception as e:
                 result["errors"].append(

calkit/tests/cli/test_core.py

@@ -44,3 +44,25 @@ def test_optional_value_command():
     # Tokens after -- are not rewritten (they're arguments, not options)
     result = runner.invoke(app, ["--", "--hub"])
     assert "hub=None" in result.output
+
+
+def test_warn(capsys) -> None:
+    import io
+
+    import pytest
+    from rich.console import Console
+
+    from calkit.cli.core import raise_error, warn
+
+    warn("plain")
+    assert capsys.readouterr().out == "Warning: plain\n"
+    # Under a spinner, a warning or error goes above it rather than straight
+    # to the terminal, where it would share the spinner's line
+    out = io.StringIO()
+    with Console(file=out, force_terminal=True).status("Working"):
+        warn("careful")
+        with pytest.raises(typer.Exit):
+            raise_error("broken")
+    assert capsys.readouterr() == ("", "")
+    assert "Warning: careful" in out.getvalue()
+    assert "Error: broken" in out.getvalue()