@scrypted/arlo 0.11.26 → 0.11.28

package/venv/lib/python3.10/site-packages/pip/_vendor/rich/progress_bar.py

@@ -1,216 +0,0 @@
-import math
-from functools import lru_cache
-from time import monotonic
-from typing import Iterable, List, Optional
-
-from .color import Color, blend_rgb
-from .color_triplet import ColorTriplet
-from .console import Console, ConsoleOptions, RenderResult
-from .jupyter import JupyterMixin
-from .measure import Measurement
-from .segment import Segment
-from .style import Style, StyleType
-
-# Number of characters before 'pulse' animation repeats
-PULSE_SIZE = 20
-
-
-class ProgressBar(JupyterMixin):
-    """Renders a (progress) bar. Used by rich.progress.
-
-    Args:
-        total (float, optional): Number of steps in the bar. Defaults to 100.
-        completed (float, optional): Number of steps completed. Defaults to 0.
-        width (int, optional): Width of the bar, or ``None`` for maximum width. Defaults to None.
-        pulse (bool, optional): Enable pulse effect. Defaults to False.
-        style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
-        complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
-        finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.done".
-        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
-        animation_time (Optional[float], optional): Time in seconds to use for animation, or None to use system time.
-    """
-
-    def __init__(
-        self,
-        total: float = 100.0,
-        completed: float = 0,
-        width: Optional[int] = None,
-        pulse: bool = False,
-        style: StyleType = "bar.back",
-        complete_style: StyleType = "bar.complete",
-        finished_style: StyleType = "bar.finished",
-        pulse_style: StyleType = "bar.pulse",
-        animation_time: Optional[float] = None,
-    ):
-        self.total = total
-        self.completed = completed
-        self.width = width
-        self.pulse = pulse
-        self.style = style
-        self.complete_style = complete_style
-        self.finished_style = finished_style
-        self.pulse_style = pulse_style
-        self.animation_time = animation_time
-
-        self._pulse_segments: Optional[List[Segment]] = None
-
-    def __repr__(self) -> str:
-        return f"<Bar {self.completed!r} of {self.total!r}>"
-
-    @property
-    def percentage_completed(self) -> float:
-        """Calculate percentage complete."""
-        completed = (self.completed / self.total) * 100.0
-        completed = min(100, max(0.0, completed))
-        return completed
-
-    @lru_cache(maxsize=16)
-    def _get_pulse_segments(
-        self,
-        fore_style: Style,
-        back_style: Style,
-        color_system: str,
-        no_color: bool,
-        ascii: bool = False,
-    ) -> List[Segment]:
-        """Get a list of segments to render a pulse animation.
-
-        Returns:
-            List[Segment]: A list of segments, one segment per character.
-        """
-        bar = "-" if ascii else "━"
-        segments: List[Segment] = []
-        if color_system not in ("standard", "eight_bit", "truecolor") or no_color:
-            segments += [Segment(bar, fore_style)] * (PULSE_SIZE // 2)
-            segments += [Segment(" " if no_color else bar, back_style)] * (
-                PULSE_SIZE - (PULSE_SIZE // 2)
-            )
-            return segments
-
-        append = segments.append
-        fore_color = (
-            fore_style.color.get_truecolor()
-            if fore_style.color
-            else ColorTriplet(255, 0, 255)
-        )
-        back_color = (
-            back_style.color.get_truecolor()
-            if back_style.color
-            else ColorTriplet(0, 0, 0)
-        )
-        cos = math.cos
-        pi = math.pi
-        _Segment = Segment
-        _Style = Style
-        from_triplet = Color.from_triplet
-
-        for index in range(PULSE_SIZE):
-            position = index / PULSE_SIZE
-            fade = 0.5 + cos((position * pi * 2)) / 2.0
-            color = blend_rgb(fore_color, back_color, cross_fade=fade)
-            append(_Segment(bar, _Style(color=from_triplet(color))))
-        return segments
-
-    def update(self, completed: float, total: Optional[float] = None) -> None:
-        """Update progress with new values.
-
-        Args:
-            completed (float): Number of steps completed.
-            total (float, optional): Total number of steps, or ``None`` to not change. Defaults to None.
-        """
-        self.completed = completed
-        self.total = total if total is not None else self.total
-
-    def _render_pulse(
-        self, console: Console, width: int, ascii: bool = False
-    ) -> Iterable[Segment]:
-        """Renders the pulse animation.
-
-        Args:
-            console (Console): Console instance.
-            width (int): Width in characters of pulse animation.
-
-        Returns:
-            RenderResult: [description]
-
-        Yields:
-            Iterator[Segment]: Segments to render pulse
-        """
-        fore_style = console.get_style(self.pulse_style, default="white")
-        back_style = console.get_style(self.style, default="black")
-
-        pulse_segments = self._get_pulse_segments(
-            fore_style, back_style, console.color_system, console.no_color, ascii=ascii
-        )
-        segment_count = len(pulse_segments)
-        current_time = (
-            monotonic() if self.animation_time is None else self.animation_time
-        )
-        segments = pulse_segments * (int(width / segment_count) + 2)
-        offset = int(-current_time * 15) % segment_count
-        segments = segments[offset : offset + width]
-        yield from segments
-
-    def __rich_console__(
-        self, console: Console, options: ConsoleOptions
-    ) -> RenderResult:
-
-        width = min(self.width or options.max_width, options.max_width)
-        ascii = options.legacy_windows or options.ascii_only
-        if self.pulse:
-            yield from self._render_pulse(console, width, ascii=ascii)
-            return
-
-        completed = min(self.total, max(0, self.completed))
-
-        bar = "-" if ascii else "━"
-        half_bar_right = " " if ascii else "╸"
-        half_bar_left = " " if ascii else "╺"
-        complete_halves = (
-            int(width * 2 * completed / self.total) if self.total else width * 2
-        )
-        bar_count = complete_halves // 2
-        half_bar_count = complete_halves % 2
-        style = console.get_style(self.style)
-        complete_style = console.get_style(
-            self.complete_style if self.completed < self.total else self.finished_style
-        )
-        _Segment = Segment
-        if bar_count:
-            yield _Segment(bar * bar_count, complete_style)
-        if half_bar_count:
-            yield _Segment(half_bar_right * half_bar_count, complete_style)
-
-        if not console.no_color:
-            remaining_bars = width - bar_count - half_bar_count
-            if remaining_bars and console.color_system is not None:
-                if not half_bar_count and bar_count:
-                    yield _Segment(half_bar_left, style)
-                    remaining_bars -= 1
-                if remaining_bars:
-                    yield _Segment(bar * remaining_bars, style)
-
-    def __rich_measure__(
-        self, console: Console, options: ConsoleOptions
-    ) -> Measurement:
-        return (
-            Measurement(self.width, self.width)
-            if self.width is not None
-            else Measurement(4, options.max_width)
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    console = Console()
-    bar = ProgressBar(width=50, total=100)
-
-    import time
-
-    console.show_cursor(False)
-    for n in range(0, 101, 1):
-        bar.update(n)
-        console.print(bar)
-        console.file.write("\r")
-        time.sleep(0.05)
-    console.show_cursor(True)
-    console.print()

package/venv/lib/python3.10/site-packages/pip/_vendor/rich/prompt.py

@@ -1,376 +0,0 @@
-from typing import Any, Generic, List, Optional, TextIO, TypeVar, Union, overload
-
-from . import get_console
-from .console import Console
-from .text import Text, TextType
-
-PromptType = TypeVar("PromptType")
-DefaultType = TypeVar("DefaultType")
-
-
-class PromptError(Exception):
-    """Exception base class for prompt related errors."""
-
-
-class InvalidResponse(PromptError):
-    """Exception to indicate a response was invalid. Raise this within process_response() to indicate an error
-    and provide an error message.
-
-    Args:
-        message (Union[str, Text]): Error message.
-    """
-
-    def __init__(self, message: TextType) -> None:
-        self.message = message
-
-    def __rich__(self) -> TextType:
-        return self.message
-
-
-class PromptBase(Generic[PromptType]):
-    """Ask the user for input until a valid response is received. This is the base class, see one of
-    the concrete classes for examples.
-
-    Args:
-        prompt (TextType, optional): Prompt text. Defaults to "".
-        console (Console, optional): A Console instance or None to use global console. Defaults to None.
-        password (bool, optional): Enable password input. Defaults to False.
-        choices (List[str], optional): A list of valid choices. Defaults to None.
-        show_default (bool, optional): Show default in prompt. Defaults to True.
-        show_choices (bool, optional): Show choices in prompt. Defaults to True.
-    """
-
-    response_type: type = str
-
-    validate_error_message = "[prompt.invalid]Please enter a valid value"
-    illegal_choice_message = (
-        "[prompt.invalid.choice]Please select one of the available options"
-    )
-    prompt_suffix = ": "
-
-    choices: Optional[List[str]] = None
-
-    def __init__(
-        self,
-        prompt: TextType = "",
-        *,
-        console: Optional[Console] = None,
-        password: bool = False,
-        choices: Optional[List[str]] = None,
-        show_default: bool = True,
-        show_choices: bool = True,
-    ) -> None:
-        self.console = console or get_console()
-        self.prompt = (
-            Text.from_markup(prompt, style="prompt")
-            if isinstance(prompt, str)
-            else prompt
-        )
-        self.password = password
-        if choices is not None:
-            self.choices = choices
-        self.show_default = show_default
-        self.show_choices = show_choices
-
-    @classmethod
-    @overload
-    def ask(
-        cls,
-        prompt: TextType = "",
-        *,
-        console: Optional[Console] = None,
-        password: bool = False,
-        choices: Optional[List[str]] = None,
-        show_default: bool = True,
-        show_choices: bool = True,
-        default: DefaultType,
-        stream: Optional[TextIO] = None,
-    ) -> Union[DefaultType, PromptType]:
-        ...
-
-    @classmethod
-    @overload
-    def ask(
-        cls,
-        prompt: TextType = "",
-        *,
-        console: Optional[Console] = None,
-        password: bool = False,
-        choices: Optional[List[str]] = None,
-        show_default: bool = True,
-        show_choices: bool = True,
-        stream: Optional[TextIO] = None,
-    ) -> PromptType:
-        ...
-
-    @classmethod
-    def ask(
-        cls,
-        prompt: TextType = "",
-        *,
-        console: Optional[Console] = None,
-        password: bool = False,
-        choices: Optional[List[str]] = None,
-        show_default: bool = True,
-        show_choices: bool = True,
-        default: Any = ...,
-        stream: Optional[TextIO] = None,
-    ) -> Any:
-        """Shortcut to construct and run a prompt loop and return the result.
-
-        Example:
-            >>> filename = Prompt.ask("Enter a filename")
-
-        Args:
-            prompt (TextType, optional): Prompt text. Defaults to "".
-            console (Console, optional): A Console instance or None to use global console. Defaults to None.
-            password (bool, optional): Enable password input. Defaults to False.
-            choices (List[str], optional): A list of valid choices. Defaults to None.
-            show_default (bool, optional): Show default in prompt. Defaults to True.
-            show_choices (bool, optional): Show choices in prompt. Defaults to True.
-            stream (TextIO, optional): Optional text file open for reading to get input. Defaults to None.
-        """
-        _prompt = cls(
-            prompt,
-            console=console,
-            password=password,
-            choices=choices,
-            show_default=show_default,
-            show_choices=show_choices,
-        )
-        return _prompt(default=default, stream=stream)
-
-    def render_default(self, default: DefaultType) -> Text:
-        """Turn the supplied default in to a Text instance.
-
-        Args:
-            default (DefaultType): Default value.
-
-        Returns:
-            Text: Text containing rendering of default value.
-        """
-        return Text(f"({default})", "prompt.default")
-
-    def make_prompt(self, default: DefaultType) -> Text:
-        """Make prompt text.
-
-        Args:
-            default (DefaultType): Default value.
-
-        Returns:
-            Text: Text to display in prompt.
-        """
-        prompt = self.prompt.copy()
-        prompt.end = ""
-
-        if self.show_choices and self.choices:
-            _choices = "/".join(self.choices)
-            choices = f"[{_choices}]"
-            prompt.append(" ")
-            prompt.append(choices, "prompt.choices")
-
-        if (
-            default != ...
-            and self.show_default
-            and isinstance(default, (str, self.response_type))
-        ):
-            prompt.append(" ")
-            _default = self.render_default(default)
-            prompt.append(_default)
-
-        prompt.append(self.prompt_suffix)
-
-        return prompt
-
-    @classmethod
-    def get_input(
-        cls,
-        console: Console,
-        prompt: TextType,
-        password: bool,
-        stream: Optional[TextIO] = None,
-    ) -> str:
-        """Get input from user.
-
-        Args:
-            console (Console): Console instance.
-            prompt (TextType): Prompt text.
-            password (bool): Enable password entry.
-
-        Returns:
-            str: String from user.
-        """
-        return console.input(prompt, password=password, stream=stream)
-
-    def check_choice(self, value: str) -> bool:
-        """Check value is in the list of valid choices.
-
-        Args:
-            value (str): Value entered by user.
-
-        Returns:
-            bool: True if choice was valid, otherwise False.
-        """
-        assert self.choices is not None
-        return value.strip() in self.choices
-
-    def process_response(self, value: str) -> PromptType:
-        """Process response from user, convert to prompt type.
-
-        Args:
-            value (str): String typed by user.
-
-        Raises:
-            InvalidResponse: If ``value`` is invalid.
-
-        Returns:
-            PromptType: The value to be returned from ask method.
-        """
-        value = value.strip()
-        try:
-            return_value = self.response_type(value)
-        except ValueError:
-            raise InvalidResponse(self.validate_error_message)
-
-        if self.choices is not None and not self.check_choice(value):
-            raise InvalidResponse(self.illegal_choice_message)
-
-        return return_value  # type: ignore
-
-    def on_validate_error(self, value: str, error: InvalidResponse) -> None:
-        """Called to handle validation error.
-
-        Args:
-            value (str): String entered by user.
-            error (InvalidResponse): Exception instance the initiated the error.
-        """
-        self.console.print(error)
-
-    def pre_prompt(self) -> None:
-        """Hook to display something before the prompt."""
-
-    @overload
-    def __call__(self, *, stream: Optional[TextIO] = None) -> PromptType:
-        ...
-
-    @overload
-    def __call__(
-        self, *, default: DefaultType, stream: Optional[TextIO] = None
-    ) -> Union[PromptType, DefaultType]:
-        ...
-
-    def __call__(self, *, default: Any = ..., stream: Optional[TextIO] = None) -> Any:
-        """Run the prompt loop.
-
-        Args:
-            default (Any, optional): Optional default value.
-
-        Returns:
-            PromptType: Processed value.
-        """
-        while True:
-            self.pre_prompt()
-            prompt = self.make_prompt(default)
-            value = self.get_input(self.console, prompt, self.password, stream=stream)
-            if value == "" and default != ...:
-                return default
-            try:
-                return_value = self.process_response(value)
-            except InvalidResponse as error:
-                self.on_validate_error(value, error)
-                continue
-            else:
-                return return_value
-
-
-class Prompt(PromptBase[str]):
-    """A prompt that returns a str.
-
-    Example:
-        >>> name = Prompt.ask("Enter your name")
-
-
-    """
-
-    response_type = str
-
-
-class IntPrompt(PromptBase[int]):
-    """A prompt that returns an integer.
-
-    Example:
-        >>> burrito_count = IntPrompt.ask("How many burritos do you want to order")
-
-    """
-
-    response_type = int
-    validate_error_message = "[prompt.invalid]Please enter a valid integer number"
-
-
-class FloatPrompt(PromptBase[int]):
-    """A prompt that returns a float.
-
-    Example:
-        >>> temperature = FloatPrompt.ask("Enter desired temperature")
-
-    """
-
-    response_type = float
-    validate_error_message = "[prompt.invalid]Please enter a number"
-
-
-class Confirm(PromptBase[bool]):
-    """A yes / no confirmation prompt.
-
-    Example:
-        >>> if Confirm.ask("Continue"):
-                run_job()
-
-    """
-
-    response_type = bool
-    validate_error_message = "[prompt.invalid]Please enter Y or N"
-    choices: List[str] = ["y", "n"]
-
-    def render_default(self, default: DefaultType) -> Text:
-        """Render the default as (y) or (n) rather than True/False."""
-        yes, no = self.choices
-        return Text(f"({yes})" if default else f"({no})", style="prompt.default")
-
-    def process_response(self, value: str) -> bool:
-        """Convert choices to a bool."""
-        value = value.strip().lower()
-        if value not in self.choices:
-            raise InvalidResponse(self.validate_error_message)
-        return value == self.choices[0]
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    from pip._vendor.rich import print
-
-    if Confirm.ask("Run [i]prompt[/i] tests?", default=True):
-        while True:
-            result = IntPrompt.ask(
-                ":rocket: Enter a number between [b]1[/b] and [b]10[/b]", default=5
-            )
-            if result >= 1 and result <= 10:
-                break
-            print(":pile_of_poo: [prompt.invalid]Number must be between 1 and 10")
-        print(f"number={result}")
-
-        while True:
-            password = Prompt.ask(
-                "Please enter a password [cyan](must be at least 5 characters)",
-                password=True,
-            )
-            if len(password) >= 5:
-                break
-            print("[prompt.invalid]password too short")
-        print(f"password={password!r}")
-
-        fruit = Prompt.ask("Enter a fruit", choices=["apple", "orange", "pear"])
-        print(f"fruit={fruit!r}")
-
-    else:
-        print("[b]OK :loudly_crying_face:")

package/venv/lib/python3.10/site-packages/pip/_vendor/rich/protocol.py

@@ -1,42 +0,0 @@
-from typing import Any, Callable, cast, Set, TYPE_CHECKING
-from inspect import isclass
-
-if TYPE_CHECKING:
-    from pip._vendor.rich.console import RenderableType
-
-_GIBBERISH = """aihwerij235234ljsdnp34ksodfipwoe234234jlskjdf"""
-
-
-def is_renderable(check_object: Any) -> bool:
-    """Check if an object may be rendered by Rich."""
-    return (
-        isinstance(check_object, str)
-        or hasattr(check_object, "__rich__")
-        or hasattr(check_object, "__rich_console__")
-    )
-
-
-def rich_cast(renderable: object) -> "RenderableType":
-    """Cast an object to a renderable by calling __rich__ if present.
-
-    Args:
-        renderable (object): A potentially renderable object
-
-    Returns:
-        object: The result of recursively calling __rich__.
-    """
-    from pip._vendor.rich.console import RenderableType
-
-    rich_visited_set: Set[type] = set()  # Prevent potential infinite loop
-    while hasattr(renderable, "__rich__") and not isclass(renderable):
-        # Detect object which claim to have all the attributes
-        if hasattr(renderable, _GIBBERISH):
-            return repr(renderable)
-        cast_method = getattr(renderable, "__rich__")
-        renderable = cast_method()
-        renderable_type = type(renderable)
-        if renderable_type in rich_visited_set:
-            break
-        rich_visited_set.add(renderable_type)
-
-    return cast(RenderableType, renderable)

package/venv/lib/python3.10/site-packages/pip/_vendor/rich/region.py

@@ -1,10 +0,0 @@
-from typing import NamedTuple
-
-
-class Region(NamedTuple):
-    """Defines a rectangular region of the screen."""
-
-    x: int
-    y: int
-    width: int
-    height: int