@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/pip/_vendor/rich/repr.py

@@ -1,149 +0,0 @@
-import inspect
-from functools import partial
-from typing import (
-    Any,
-    Callable,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-
-T = TypeVar("T")
-
-
-Result = Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]
-RichReprResult = Result
-
-
-class ReprError(Exception):
-    """An error occurred when attempting to build a repr."""
-
-
-@overload
-def auto(cls: Optional[Type[T]]) -> Type[T]:
-    ...
-
-
-@overload
-def auto(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:
-    ...
-
-
-def auto(
-    cls: Optional[Type[T]] = None, *, angular: Optional[bool] = None
-) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
-    """Class decorator to create __repr__ from __rich_repr__"""
-
-    def do_replace(cls: Type[T], angular: Optional[bool] = None) -> Type[T]:
-        def auto_repr(self: T) -> str:
-            """Create repr string from __rich_repr__"""
-            repr_str: List[str] = []
-            append = repr_str.append
-
-            angular: bool = getattr(self.__rich_repr__, "angular", False)  # type: ignore[attr-defined]
-            for arg in self.__rich_repr__():  # type: ignore[attr-defined]
-                if isinstance(arg, tuple):
-                    if len(arg) == 1:
-                        append(repr(arg[0]))
-                    else:
-                        key, value, *default = arg
-                        if key is None:
-                            append(repr(value))
-                        else:
-                            if default and default[0] == value:
-                                continue
-                            append(f"{key}={value!r}")
-                else:
-                    append(repr(arg))
-            if angular:
-                return f"<{self.__class__.__name__} {' '.join(repr_str)}>"
-            else:
-                return f"{self.__class__.__name__}({', '.join(repr_str)})"
-
-        def auto_rich_repr(self: Type[T]) -> Result:
-            """Auto generate __rich_rep__ from signature of __init__"""
-            try:
-                signature = inspect.signature(self.__init__)
-                for name, param in signature.parameters.items():
-                    if param.kind == param.POSITIONAL_ONLY:
-                        yield getattr(self, name)
-                    elif param.kind in (
-                        param.POSITIONAL_OR_KEYWORD,
-                        param.KEYWORD_ONLY,
-                    ):
-                        if param.default is param.empty:
-                            yield getattr(self, param.name)
-                        else:
-                            yield param.name, getattr(self, param.name), param.default
-            except Exception as error:
-                raise ReprError(
-                    f"Failed to auto generate __rich_repr__; {error}"
-                ) from None
-
-        if not hasattr(cls, "__rich_repr__"):
-            auto_rich_repr.__doc__ = "Build a rich repr"
-            cls.__rich_repr__ = auto_rich_repr  # type: ignore[attr-defined]
-
-        auto_repr.__doc__ = "Return repr(self)"
-        cls.__repr__ = auto_repr  # type: ignore[assignment]
-        if angular is not None:
-            cls.__rich_repr__.angular = angular  # type: ignore[attr-defined]
-        return cls
-
-    if cls is None:
-        return partial(do_replace, angular=angular)
-    else:
-        return do_replace(cls, angular=angular)
-
-
-@overload
-def rich_repr(cls: Optional[Type[T]]) -> Type[T]:
-    ...
-
-
-@overload
-def rich_repr(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:
-    ...
-
-
-def rich_repr(
-    cls: Optional[Type[T]] = None, *, angular: bool = False
-) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
-    if cls is None:
-        return auto(angular=angular)
-    else:
-        return auto(cls)
-
-
-if __name__ == "__main__":
-
-    @auto
-    class Foo:
-        def __rich_repr__(self) -> Result:
-            yield "foo"
-            yield "bar", {"shopping": ["eggs", "ham", "pineapple"]}
-            yield "buy", "hand sanitizer"
-
-    foo = Foo()
-    from pip._vendor.rich.console import Console
-
-    console = Console()
-
-    console.rule("Standard repr")
-    console.print(foo)
-
-    console.print(foo, width=60)
-    console.print(foo, width=30)
-
-    console.rule("Angular repr")
-    Foo.__rich_repr__.angular = True  # type: ignore[attr-defined]
-
-    console.print(foo)
-
-    console.print(foo, width=60)
-    console.print(foo, width=30)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/pip/_vendor/rich/rule.py

@@ -1,130 +0,0 @@
-from typing import Union
-
-from .align import AlignMethod
-from .cells import cell_len, set_cell_size
-from .console import Console, ConsoleOptions, RenderResult
-from .jupyter import JupyterMixin
-from .measure import Measurement
-from .style import Style
-from .text import Text
-
-
-class Rule(JupyterMixin):
-    """A console renderable to draw a horizontal rule (line).
-
-    Args:
-        title (Union[str, Text], optional): Text to render in the rule. Defaults to "".
-        characters (str, optional): Character(s) used to draw the line. Defaults to "─".
-        style (StyleType, optional): Style of Rule. Defaults to "rule.line".
-        end (str, optional): Character at end of Rule. defaults to "\\\\n"
-        align (str, optional): How to align the title, one of "left", "center", or "right". Defaults to "center".
-    """
-
-    def __init__(
-        self,
-        title: Union[str, Text] = "",
-        *,
-        characters: str = "─",
-        style: Union[str, Style] = "rule.line",
-        end: str = "\n",
-        align: AlignMethod = "center",
-    ) -> None:
-        if cell_len(characters) < 1:
-            raise ValueError(
-                "'characters' argument must have a cell width of at least 1"
-            )
-        if align not in ("left", "center", "right"):
-            raise ValueError(
-                f'invalid value for align, expected "left", "center", "right" (not {align!r})'
-            )
-        self.title = title
-        self.characters = characters
-        self.style = style
-        self.end = end
-        self.align = align
-
-    def __repr__(self) -> str:
-        return f"Rule({self.title!r}, {self.characters!r})"
-
-    def __rich_console__(
-        self, console: Console, options: ConsoleOptions
-    ) -> RenderResult:
-        width = options.max_width
-
-        characters = (
-            "-"
-            if (options.ascii_only and not self.characters.isascii())
-            else self.characters
-        )
-
-        chars_len = cell_len(characters)
-        if not self.title:
-            yield self._rule_line(chars_len, width)
-            return
-
-        if isinstance(self.title, Text):
-            title_text = self.title
-        else:
-            title_text = console.render_str(self.title, style="rule.text")
-
-        title_text.plain = title_text.plain.replace("\n", " ")
-        title_text.expand_tabs()
-
-        required_space = 4 if self.align == "center" else 2
-        truncate_width = max(0, width - required_space)
-        if not truncate_width:
-            yield self._rule_line(chars_len, width)
-            return
-
-        rule_text = Text(end=self.end)
-        if self.align == "center":
-            title_text.truncate(truncate_width, overflow="ellipsis")
-            side_width = (width - cell_len(title_text.plain)) // 2
-            left = Text(characters * (side_width // chars_len + 1))
-            left.truncate(side_width - 1)
-            right_length = width - cell_len(left.plain) - cell_len(title_text.plain)
-            right = Text(characters * (side_width // chars_len + 1))
-            right.truncate(right_length)
-            rule_text.append(left.plain + " ", self.style)
-            rule_text.append(title_text)
-            rule_text.append(" " + right.plain, self.style)
-        elif self.align == "left":
-            title_text.truncate(truncate_width, overflow="ellipsis")
-            rule_text.append(title_text)
-            rule_text.append(" ")
-            rule_text.append(characters * (width - rule_text.cell_len), self.style)
-        elif self.align == "right":
-            title_text.truncate(truncate_width, overflow="ellipsis")
-            rule_text.append(characters * (width - title_text.cell_len - 1), self.style)
-            rule_text.append(" ")
-            rule_text.append(title_text)
-
-        rule_text.plain = set_cell_size(rule_text.plain, width)
-        yield rule_text
-
-    def _rule_line(self, chars_len: int, width: int) -> Text:
-        rule_text = Text(self.characters * ((width // chars_len) + 1), self.style)
-        rule_text.truncate(width)
-        rule_text.plain = set_cell_size(rule_text.plain, width)
-        return rule_text
-
-    def __rich_measure__(
-        self, console: Console, options: ConsoleOptions
-    ) -> Measurement:
-        return Measurement(1, 1)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from pip._vendor.rich.console import Console
-
-    try:
-        text = sys.argv[1]
-    except IndexError:
-        text = "Hello, World"
-    console = Console()
-    console.print(Rule(title=text))
-
-    console = Console()
-    console.print(Rule("foo"), width=4)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/pip/_vendor/rich/scope.py

@@ -1,86 +0,0 @@
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Optional, Tuple
-
-from .highlighter import ReprHighlighter
-from .panel import Panel
-from .pretty import Pretty
-from .table import Table
-from .text import Text, TextType
-
-if TYPE_CHECKING:
-    from .console import ConsoleRenderable
-
-
-def render_scope(
-    scope: "Mapping[str, Any]",
-    *,
-    title: Optional[TextType] = None,
-    sort_keys: bool = True,
-    indent_guides: bool = False,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-) -> "ConsoleRenderable":
-    """Render python variables in a given scope.
-
-    Args:
-        scope (Mapping): A mapping containing variable names and values.
-        title (str, optional): Optional title. Defaults to None.
-        sort_keys (bool, optional): Enable sorting of items. Defaults to True.
-        indent_guides (bool, optional): Enable indentation guides. Defaults to False.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.
-
-    Returns:
-        ConsoleRenderable: A renderable object.
-    """
-    highlighter = ReprHighlighter()
-    items_table = Table.grid(padding=(0, 1), expand=False)
-    items_table.add_column(justify="right")
-
-    def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]:
-        """Sort special variables first, then alphabetically."""
-        key, _ = item
-        return (not key.startswith("__"), key.lower())
-
-    items = sorted(scope.items(), key=sort_items) if sort_keys else scope.items()
-    for key, value in items:
-        key_text = Text.assemble(
-            (key, "scope.key.special" if key.startswith("__") else "scope.key"),
-            (" =", "scope.equals"),
-        )
-        items_table.add_row(
-            key_text,
-            Pretty(
-                value,
-                highlighter=highlighter,
-                indent_guides=indent_guides,
-                max_length=max_length,
-                max_string=max_string,
-            ),
-        )
-    return Panel.fit(
-        items_table,
-        title=title,
-        border_style="scope.border",
-        padding=(0, 1),
-    )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich import print
-
-    print()
-
-    def test(foo: float, bar: float) -> None:
-        list_of_things = [1, 2, 3, None, 4, True, False, "Hello World"]
-        dict_of_things = {
-            "version": "1.1",
-            "method": "confirmFruitPurchase",
-            "params": [["apple", "orange", "mangoes", "pomelo"], 1.123],
-            "id": "194521489",
-        }
-        print(render_scope(locals(), title="[i]locals", sort_keys=False))
-
-    test(20.3423, 3.1427)
-    print()

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/pip/_vendor/rich/screen.py

@@ -1,54 +0,0 @@
-from typing import Optional, TYPE_CHECKING
-
-from .segment import Segment
-from .style import StyleType
-from ._loop import loop_last
-
-
-if TYPE_CHECKING:
-    from .console import (
-        Console,
-        ConsoleOptions,
-        RenderResult,
-        RenderableType,
-        Group,
-    )
-
-
-class Screen:
-    """A renderable that fills the terminal screen and crops excess.
-
-    Args:
-        renderable (RenderableType): Child renderable.
-        style (StyleType, optional): Optional background style. Defaults to None.
-    """
-
-    renderable: "RenderableType"
-
-    def __init__(
-        self,
-        *renderables: "RenderableType",
-        style: Optional[StyleType] = None,
-        application_mode: bool = False,
-    ) -> None:
-        from pip._vendor.rich.console import Group
-
-        self.renderable = Group(*renderables)
-        self.style = style
-        self.application_mode = application_mode
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        width, height = options.size
-        style = console.get_style(self.style) if self.style else None
-        render_options = options.update(width=width, height=height)
-        lines = console.render_lines(
-            self.renderable or "", render_options, style=style, pad=True
-        )
-        lines = Segment.set_shape(lines, width, height, style=style)
-        new_line = Segment("\n\r") if self.application_mode else Segment.line()
-        for last, line in loop_last(lines):
-            yield from line
-            if not last:
-                yield new_line