@scrypted/arlo 0.11.26 → 0.11.28

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

@@ -1,16 +0,0 @@
-from typing import List, TypeVar
-
-T = TypeVar("T")
-
-
-class Stack(List[T]):
-    """A small shim over builtin list."""
-
-    @property
-    def top(self) -> T:
-        """Get top of stack."""
-        return self[-1]
-
-    def push(self, item: T) -> None:
-        """Push an item on to the stack (append in stack nomenclature)."""
-        self.append(item)

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

@@ -1,19 +0,0 @@
-"""
-Timer context manager, only used in debug.
-
-"""
-
-from time import time
-
-import contextlib
-from typing import Generator
-
-
-@contextlib.contextmanager
-def timer(subject: str = "time") -> Generator[None, None, None]:
-    """print the elapsed time. (only used in debugging)"""
-    start = time()
-    yield
-    elapsed = time() - start
-    elapsed_ms = elapsed * 1000
-    print(f"{subject} elapsed {elapsed_ms:.1f}ms")

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

@@ -1,72 +0,0 @@
-import sys
-from dataclasses import dataclass
-
-
-@dataclass
-class WindowsConsoleFeatures:
-    """Windows features available."""
-
-    vt: bool = False
-    """The console supports VT codes."""
-    truecolor: bool = False
-    """The console supports truecolor."""
-
-
-try:
-    import ctypes
-    from ctypes import LibraryLoader, wintypes
-
-    if sys.platform == "win32":
-        windll = LibraryLoader(ctypes.WinDLL)
-    else:
-        windll = None
-        raise ImportError("Not windows")
-except (AttributeError, ImportError, ValueError):
-
-    # Fallback if we can't load the Windows DLL
-    def get_windows_console_features() -> WindowsConsoleFeatures:
-        features = WindowsConsoleFeatures()
-        return features
-
-else:
-
-    STDOUT = -11
-    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
-    _GetConsoleMode = windll.kernel32.GetConsoleMode
-    _GetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.LPDWORD]
-    _GetConsoleMode.restype = wintypes.BOOL
-
-    _GetStdHandle = windll.kernel32.GetStdHandle
-    _GetStdHandle.argtypes = [
-        wintypes.DWORD,
-    ]
-    _GetStdHandle.restype = wintypes.HANDLE
-
-    def get_windows_console_features() -> WindowsConsoleFeatures:
-        """Get windows console features.
-
-        Returns:
-            WindowsConsoleFeatures: An instance of WindowsConsoleFeatures.
-        """
-        handle = _GetStdHandle(STDOUT)
-        console_mode = wintypes.DWORD()
-        result = _GetConsoleMode(handle, console_mode)
-        vt = bool(result and console_mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-        truecolor = False
-        if vt:
-            win_version = sys.getwindowsversion()
-            truecolor = win_version.major > 10 or (
-                win_version.major == 10 and win_version.build >= 15063
-            )
-        features = WindowsConsoleFeatures(vt=vt, truecolor=truecolor)
-        return features
-
-
-if __name__ == "__main__":
-    import platform
-
-    features = get_windows_console_features()
-    from pip._vendor.rich import print
-
-    print(f'platform="{platform.system()}"')
-    print(repr(features))

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

@@ -1,55 +0,0 @@
-import re
-from typing import Iterable, List, Tuple
-
-from .cells import cell_len, chop_cells
-from ._loop import loop_last
-
-re_word = re.compile(r"\s*\S+\s*")
-
-
-def words(text: str) -> Iterable[Tuple[int, int, str]]:
-    position = 0
-    word_match = re_word.match(text, position)
-    while word_match is not None:
-        start, end = word_match.span()
-        word = word_match.group(0)
-        yield start, end, word
-        word_match = re_word.match(text, end)
-
-
-def divide_line(text: str, width: int, fold: bool = True) -> List[int]:
-    divides: List[int] = []
-    append = divides.append
-    line_position = 0
-    _cell_len = cell_len
-    for start, _end, word in words(text):
-        word_length = _cell_len(word.rstrip())
-        if line_position + word_length > width:
-            if word_length > width:
-                if fold:
-                    for last, line in loop_last(
-                        chop_cells(word, width, position=line_position)
-                    ):
-                        if last:
-                            line_position = _cell_len(line)
-                        else:
-                            start += len(line)
-                            append(start)
-                else:
-                    if start:
-                        append(start)
-                    line_position = _cell_len(word)
-            elif line_position and start:
-                append(start)
-                line_position = _cell_len(word)
-        else:
-            line_position += _cell_len(word)
-    return divides
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from .console import Console
-
-    console = Console(width=10)
-    console.print("12345 abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ 12345")
-    print(chop_cells("abcdefghijklmnopqrstuvwxyz", 10, position=2))

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

@@ -1,33 +0,0 @@
-from abc import ABC
-
-
-class RichRenderable(ABC):
-    """An abstract base class for Rich renderables.
-
-    Note that there is no need to extend this class, the intended use is to check if an
-    object supports the Rich renderable protocol. For example::
-
-        if isinstance(my_object, RichRenderable):
-            console.print(my_object)
-
-    """
-
-    @classmethod
-    def __subclasshook__(cls, other: type) -> bool:
-        """Check if this class supports the rich render protocol."""
-        return hasattr(other, "__rich_console__") or hasattr(other, "__rich__")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich.text import Text
-
-    t = Text()
-    print(isinstance(Text, RichRenderable))
-    print(isinstance(t, RichRenderable))
-
-    class Foo:
-        pass
-
-    f = Foo()
-    print(isinstance(f, RichRenderable))
-    print(isinstance("", RichRenderable))

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

@@ -1,312 +0,0 @@
-import sys
-from itertools import chain
-from typing import TYPE_CHECKING, Iterable, Optional
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from pip._vendor.typing_extensions import Literal  # pragma: no cover
-
-from .constrain import Constrain
-from .jupyter import JupyterMixin
-from .measure import Measurement
-from .segment import Segment
-from .style import StyleType
-
-if TYPE_CHECKING:
-    from .console import Console, ConsoleOptions, RenderableType, RenderResult
-
-AlignMethod = Literal["left", "center", "right"]
-VerticalAlignMethod = Literal["top", "middle", "bottom"]
-AlignValues = AlignMethod  # TODO: deprecate AlignValues
-
-
-class Align(JupyterMixin):
-    """Align a renderable by adding spaces if necessary.
-
-    Args:
-        renderable (RenderableType): A console renderable.
-        align (AlignMethod): One of "left", "center", or "right""
-        style (StyleType, optional): An optional style to apply to the background.
-        vertical (Optional[VerticalAlginMethod], optional): Optional vertical align, one of "top", "middle", or "bottom". Defaults to None.
-        pad (bool, optional): Pad the right with spaces. Defaults to True.
-        width (int, optional): Restrict contents to given width, or None to use default width. Defaults to None.
-        height (int, optional): Set height of align renderable, or None to fit to contents. Defaults to None.
-
-    Raises:
-        ValueError: if ``align`` is not one of the expected values.
-    """
-
-    def __init__(
-        self,
-        renderable: "RenderableType",
-        align: AlignMethod = "left",
-        style: Optional[StyleType] = None,
-        *,
-        vertical: Optional[VerticalAlignMethod] = None,
-        pad: bool = True,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-    ) -> None:
-        if align not in ("left", "center", "right"):
-            raise ValueError(
-                f'invalid value for align, expected "left", "center", or "right" (not {align!r})'
-            )
-        if vertical is not None and vertical not in ("top", "middle", "bottom"):
-            raise ValueError(
-                f'invalid value for vertical, expected "top", "middle", or "bottom" (not {vertical!r})'
-            )
-        self.renderable = renderable
-        self.align = align
-        self.style = style
-        self.vertical = vertical
-        self.pad = pad
-        self.width = width
-        self.height = height
-
-    def __repr__(self) -> str:
-        return f"Align({self.renderable!r}, {self.align!r})"
-
-    @classmethod
-    def left(
-        cls,
-        renderable: "RenderableType",
-        style: Optional[StyleType] = None,
-        *,
-        vertical: Optional[VerticalAlignMethod] = None,
-        pad: bool = True,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-    ) -> "Align":
-        """Align a renderable to the left."""
-        return cls(
-            renderable,
-            "left",
-            style=style,
-            vertical=vertical,
-            pad=pad,
-            width=width,
-            height=height,
-        )
-
-    @classmethod
-    def center(
-        cls,
-        renderable: "RenderableType",
-        style: Optional[StyleType] = None,
-        *,
-        vertical: Optional[VerticalAlignMethod] = None,
-        pad: bool = True,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-    ) -> "Align":
-        """Align a renderable to the center."""
-        return cls(
-            renderable,
-            "center",
-            style=style,
-            vertical=vertical,
-            pad=pad,
-            width=width,
-            height=height,
-        )
-
-    @classmethod
-    def right(
-        cls,
-        renderable: "RenderableType",
-        style: Optional[StyleType] = None,
-        *,
-        vertical: Optional[VerticalAlignMethod] = None,
-        pad: bool = True,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-    ) -> "Align":
-        """Align a renderable to the right."""
-        return cls(
-            renderable,
-            "right",
-            style=style,
-            vertical=vertical,
-            pad=pad,
-            width=width,
-            height=height,
-        )
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        align = self.align
-        width = console.measure(self.renderable, options=options).maximum
-        rendered = console.render(
-            Constrain(
-                self.renderable, width if self.width is None else min(width, self.width)
-            ),
-            options.update(height=None),
-        )
-        lines = list(Segment.split_lines(rendered))
-        width, height = Segment.get_shape(lines)
-        lines = Segment.set_shape(lines, width, height)
-        new_line = Segment.line()
-        excess_space = options.max_width - width
-        style = console.get_style(self.style) if self.style is not None else None
-
-        def generate_segments() -> Iterable[Segment]:
-            if excess_space <= 0:
-                # Exact fit
-                for line in lines:
-                    yield from line
-                    yield new_line
-
-            elif align == "left":
-                # Pad on the right
-                pad = Segment(" " * excess_space, style) if self.pad else None
-                for line in lines:
-                    yield from line
-                    if pad:
-                        yield pad
-                    yield new_line
-
-            elif align == "center":
-                # Pad left and right
-                left = excess_space // 2
-                pad = Segment(" " * left, style)
-                pad_right = (
-                    Segment(" " * (excess_space - left), style) if self.pad else None
-                )
-                for line in lines:
-                    if left:
-                        yield pad
-                    yield from line
-                    if pad_right:
-                        yield pad_right
-                    yield new_line
-
-            elif align == "right":
-                # Padding on left
-                pad = Segment(" " * excess_space, style)
-                for line in lines:
-                    yield pad
-                    yield from line
-                    yield new_line
-
-        blank_line = (
-            Segment(f"{' ' * (self.width or options.max_width)}\n", style)
-            if self.pad
-            else Segment("\n")
-        )
-
-        def blank_lines(count: int) -> Iterable[Segment]:
-            if count > 0:
-                for _ in range(count):
-                    yield blank_line
-
-        vertical_height = self.height or options.height
-        iter_segments: Iterable[Segment]
-        if self.vertical and vertical_height is not None:
-            if self.vertical == "top":
-                bottom_space = vertical_height - height
-                iter_segments = chain(generate_segments(), blank_lines(bottom_space))
-            elif self.vertical == "middle":
-                top_space = (vertical_height - height) // 2
-                bottom_space = vertical_height - top_space - height
-                iter_segments = chain(
-                    blank_lines(top_space),
-                    generate_segments(),
-                    blank_lines(bottom_space),
-                )
-            else:  #  self.vertical == "bottom":
-                top_space = vertical_height - height
-                iter_segments = chain(blank_lines(top_space), generate_segments())
-        else:
-            iter_segments = generate_segments()
-        if self.style:
-            style = console.get_style(self.style)
-            iter_segments = Segment.apply_style(iter_segments, style)
-        yield from iter_segments
-
-    def __rich_measure__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> Measurement:
-        measurement = Measurement.get(console, options, self.renderable)
-        return measurement
-
-
-class VerticalCenter(JupyterMixin):
-    """Vertically aligns a renderable.
-
-    Warn:
-        This class is deprecated and may be removed in a future version. Use Align class with
-        `vertical="middle"`.
-
-    Args:
-        renderable (RenderableType): A renderable object.
-    """
-
-    def __init__(
-        self,
-        renderable: "RenderableType",
-        style: Optional[StyleType] = None,
-    ) -> None:
-        self.renderable = renderable
-        self.style = style
-
-    def __repr__(self) -> str:
-        return f"VerticalCenter({self.renderable!r})"
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        style = console.get_style(self.style) if self.style is not None else None
-        lines = console.render_lines(
-            self.renderable, options.update(height=None), pad=False
-        )
-        width, _height = Segment.get_shape(lines)
-        new_line = Segment.line()
-        height = options.height or options.size.height
-        top_space = (height - len(lines)) // 2
-        bottom_space = height - top_space - len(lines)
-        blank_line = Segment(f"{' ' * width}", style)
-
-        def blank_lines(count: int) -> Iterable[Segment]:
-            for _ in range(count):
-                yield blank_line
-                yield new_line
-
-        if top_space > 0:
-            yield from blank_lines(top_space)
-        for line in lines:
-            yield from line
-            yield new_line
-        if bottom_space > 0:
-            yield from blank_lines(bottom_space)
-
-    def __rich_measure__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> Measurement:
-        measurement = Measurement.get(console, options, self.renderable)
-        return measurement
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich.console import Console, Group
-    from pip._vendor.rich.highlighter import ReprHighlighter
-    from pip._vendor.rich.panel import Panel
-
-    highlighter = ReprHighlighter()
-    console = Console()
-
-    panel = Panel(
-        Group(
-            Align.left(highlighter("align='left'")),
-            Align.center(highlighter("align='center'")),
-            Align.right(highlighter("align='right'")),
-        ),
-        width=60,
-        style="on dark_blue",
-        title="Algin",
-    )
-
-    console.print(
-        Align.center(panel, vertical="middle", style="on red", height=console.height)
-    )