138 lines
4.0 KiB
Python
138 lines
4.0 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, Any, Dict, List, Optional
|
|
|
|
from rich.console import Console, RenderableType
|
|
from rich.live import Live
|
|
from rich.text import Text
|
|
|
|
from .element import Element
|
|
|
|
if TYPE_CHECKING:
|
|
from .styles.base import BaseStyle
|
|
|
|
|
|
class ProgressLine(Element):
|
|
def __init__(self, text: str | Text, parent: Progress):
|
|
self.text = text
|
|
self.parent = parent
|
|
|
|
|
|
class Progress(Live, Element):
|
|
current_message: str | Text
|
|
|
|
def __init__(
|
|
self,
|
|
title: str,
|
|
style: Optional[BaseStyle] = None,
|
|
console: Optional[Console] = None,
|
|
transient: bool = False,
|
|
transient_on_error: bool = False,
|
|
inline_logs: bool = False,
|
|
lines_to_show: int = -1,
|
|
quiet: bool = False,
|
|
**metadata: Dict[Any, Any],
|
|
) -> None:
|
|
self.title = title
|
|
self.current_message = title
|
|
self.is_error = False
|
|
self._transient_on_error = transient_on_error
|
|
self._inline_logs = inline_logs
|
|
self.lines_to_show = lines_to_show
|
|
self._quiet = quiet
|
|
|
|
self.logs: List[ProgressLine] = []
|
|
self._log_line_open = False
|
|
|
|
self._cancelled = False
|
|
|
|
Element.__init__(self, style=style, metadata=metadata)
|
|
super().__init__(console=console, refresh_per_second=8, transient=transient)
|
|
|
|
# TODO: remove this once rich uses "Self"
|
|
def __enter__(self) -> "Progress":
|
|
if self._quiet:
|
|
return self
|
|
|
|
self.start(refresh=self._renderable is not None)
|
|
|
|
return self
|
|
|
|
def __exit__(self, exc_type: type | None, *args: object) -> None:
|
|
if exc_type is KeyboardInterrupt:
|
|
self._cancelled = True
|
|
|
|
if self._quiet:
|
|
return None
|
|
|
|
super().__exit__(exc_type, *args)
|
|
|
|
def get_renderable(self) -> RenderableType:
|
|
return self.style.render_element(self, done=not self._started)
|
|
|
|
def _append_text(self, target: str | Text, text: str | Text) -> str | Text:
|
|
if isinstance(target, str) and isinstance(text, str):
|
|
return target + text
|
|
|
|
return Text.assemble(target, text)
|
|
|
|
def _split_log_text(self, text: str | Text) -> list[tuple[str | Text, bool]]:
|
|
if isinstance(text, str):
|
|
lines = text.splitlines(keepends=True)
|
|
if not lines:
|
|
return [(text, False)]
|
|
|
|
return [
|
|
(
|
|
line[:-1] if line.endswith("\n") else line,
|
|
line.endswith("\n"),
|
|
)
|
|
for line in lines
|
|
]
|
|
|
|
lines = text.split("\n", include_separator=True)
|
|
result: list[tuple[str | Text, bool]] = []
|
|
|
|
for line in lines:
|
|
ends_with_newline = line.plain.endswith("\n")
|
|
if ends_with_newline:
|
|
line = line.copy()
|
|
line.right_crop(1)
|
|
|
|
result.append((line, ends_with_newline))
|
|
|
|
return result
|
|
|
|
def log(self, text: str | Text, end: str = "\n") -> None:
|
|
if end != "\n":
|
|
text = self._append_text(text, end)
|
|
|
|
lines = self._split_log_text(text)
|
|
lines[-1] = (lines[-1][0], lines[-1][1] or end.endswith("\n"))
|
|
|
|
should_append = self._log_line_open
|
|
|
|
if self._inline_logs:
|
|
for line, is_closed in lines:
|
|
if should_append and self.logs:
|
|
self.logs[-1].text = self._append_text(self.logs[-1].text, line)
|
|
else:
|
|
self.logs.append(ProgressLine(line, self))
|
|
|
|
should_append = not is_closed
|
|
else:
|
|
if should_append:
|
|
self.current_message = self._append_text(self.current_message, text)
|
|
else:
|
|
self.current_message = text
|
|
|
|
should_append = not lines[-1][1]
|
|
|
|
self._log_line_open = should_append
|
|
|
|
def set_error(self, text: str) -> None:
|
|
self.current_message = text
|
|
self.is_error = True
|
|
self.transient = self._transient_on_error
|
|
self._log_line_open = False
|