Add files using upload-large-folder tool

llava/lib/python3.10/site-packages/pip/_vendor/rich/__main__.py

@@ -0,0 +1,273 @@
+import colorsys
+import io
+from time import process_time
+
+from pip._vendor.rich import box
+from pip._vendor.rich.color import Color
+from pip._vendor.rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
+from pip._vendor.rich.markdown import Markdown
+from pip._vendor.rich.measure import Measurement
+from pip._vendor.rich.pretty import Pretty
+from pip._vendor.rich.segment import Segment
+from pip._vendor.rich.style import Style
+from pip._vendor.rich.syntax import Syntax
+from pip._vendor.rich.table import Table
+from pip._vendor.rich.text import Text
+
+
+class ColorBox:
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        for y in range(0, 5):
+            for x in range(options.max_width):
+                h = x / options.max_width
+                l = 0.1 + ((y / 5) * 0.7)
+                r1, g1, b1 = colorsys.hls_to_rgb(h, l, 1.0)
+                r2, g2, b2 = colorsys.hls_to_rgb(h, l + 0.7 / 10, 1.0)
+                bgcolor = Color.from_rgb(r1 * 255, g1 * 255, b1 * 255)
+                color = Color.from_rgb(r2 * 255, g2 * 255, b2 * 255)
+                yield Segment("▄", Style(color=color, bgcolor=bgcolor))
+            yield Segment.line()
+
+    def __rich_measure__(
+        self, console: "Console", options: ConsoleOptions
+    ) -> Measurement:
+        return Measurement(1, options.max_width)
+
+
+def make_test_card() -> Table:
+    """Get a renderable that demonstrates a number of features."""
+    table = Table.grid(padding=1, pad_edge=True)
+    table.title = "Rich features"
+    table.add_column("Feature", no_wrap=True, justify="center", style="bold red")
+    table.add_column("Demonstration")
+
+    color_table = Table(
+        box=None,
+        expand=False,
+        show_header=False,
+        show_edge=False,
+        pad_edge=False,
+    )
+    color_table.add_row(
+        (
+            "✓ [bold green]4-bit color[/]\n"
+            "✓ [bold blue]8-bit color[/]\n"
+            "✓ [bold magenta]Truecolor (16.7 million)[/]\n"
+            "✓ [bold yellow]Dumb terminals[/]\n"
+            "✓ [bold cyan]Automatic color conversion"
+        ),
+        ColorBox(),
+    )
+
+    table.add_row("Colors", color_table)
+
+    table.add_row(
+        "Styles",
+        "All ansi styles: [bold]bold[/], [dim]dim[/], [italic]italic[/italic], [underline]underline[/], [strike]strikethrough[/], [reverse]reverse[/], and even [blink]blink[/].",
+    )
+
+    lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque in metus sed sapien ultricies pretium a at justo. Maecenas luctus velit et auctor maximus."
+    lorem_table = Table.grid(padding=1, collapse_padding=True)
+    lorem_table.pad_edge = False
+    lorem_table.add_row(
+        Text(lorem, justify="left", style="green"),
+        Text(lorem, justify="center", style="yellow"),
+        Text(lorem, justify="right", style="blue"),
+        Text(lorem, justify="full", style="red"),
+    )
+    table.add_row(
+        "Text",
+        Group(
+            Text.from_markup(
+                """Word wrap text. Justify [green]left[/], [yellow]center[/], [blue]right[/] or [red]full[/].\n"""
+            ),
+            lorem_table,
+        ),
+    )
+
+    def comparison(renderable1: RenderableType, renderable2: RenderableType) -> Table:
+        table = Table(show_header=False, pad_edge=False, box=None, expand=True)
+        table.add_column("1", ratio=1)
+        table.add_column("2", ratio=1)
+        table.add_row(renderable1, renderable2)
+        return table
+
+    table.add_row(
+        "Asian\nlanguage\nsupport",
+        ":flag_for_china:  该库支持中文，日文和韩文文本！\n:flag_for_japan:  ライブラリは中国語、日本語、韓国語のテキストをサポートしています\n:flag_for_south_korea:  이 라이브러리는 중국어, 일본어 및 한국어 텍스트를 지원합니다",
+    )
+
+    markup_example = (
+        "[bold magenta]Rich[/] supports a simple [i]bbcode[/i]-like [b]markup[/b] for [yellow]color[/], [underline]style[/], and emoji! "
+        ":+1: :apple: :ant: :bear: :baguette_bread: :bus: "
+    )
+    table.add_row("Markup", markup_example)
+
+    example_table = Table(
+        show_edge=False,
+        show_header=True,
+        expand=False,
+        row_styles=["none", "dim"],
+        box=box.SIMPLE,
+    )
+    example_table.add_column("[green]Date", style="green", no_wrap=True)
+    example_table.add_column("[blue]Title", style="blue")
+    example_table.add_column(
+        "[cyan]Production Budget",
+        style="cyan",
+        justify="right",
+        no_wrap=True,
+    )
+    example_table.add_column(
+        "[magenta]Box Office",
+        style="magenta",
+        justify="right",
+        no_wrap=True,
+    )
+    example_table.add_row(
+        "Dec 20, 2019",
+        "Star Wars: The Rise of Skywalker",
+        "$275,000,000",
+        "$375,126,118",
+    )
+    example_table.add_row(
+        "May 25, 2018",
+        "[b]Solo[/]: A Star Wars Story",
+        "$275,000,000",
+        "$393,151,347",
+    )
+    example_table.add_row(
+        "Dec 15, 2017",
+        "Star Wars Ep. VIII: The Last Jedi",
+        "$262,000,000",
+        "[bold]$1,332,539,889[/bold]",
+    )
+    example_table.add_row(
+        "May 19, 1999",
+        "Star Wars Ep. [b]I[/b]: [i]The phantom Menace",
+        "$115,000,000",
+        "$1,027,044,677",
+    )
+
+    table.add_row("Tables", example_table)
+
+    code = '''\
+def iter_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value'''
+
+    pretty_data = {
+        "foo": [
+            3.1427,
+            (
+                "Paul Atreides",
+                "Vladimir Harkonnen",
+                "Thufir Hawat",
+            ),
+        ],
+        "atomic": (False, True, None),
+    }
+    table.add_row(
+        "Syntax\nhighlighting\n&\npretty\nprinting",
+        comparison(
+            Syntax(code, "python3", line_numbers=True, indent_guides=True),
+            Pretty(pretty_data, indent_guides=True),
+        ),
+    )
+
+    markdown_example = """\
+# Markdown
+
+Supports much of the *markdown* __syntax__!
+
+- Headers
+- Basic formatting: **bold**, *italic*, `code`
+- Block quotes
+- Lists, and more...
+    """
+    table.add_row(
+        "Markdown", comparison("[cyan]" + markdown_example, Markdown(markdown_example))
+    )
+
+    table.add_row(
+        "+more!",
+        """Progress bars, columns, styled logging handler, tracebacks, etc...""",
+    )
+    return table
+
+
+if __name__ == "__main__":  # pragma: no cover
+    console = Console(
+        file=io.StringIO(),
+        force_terminal=True,
+    )
+    test_card = make_test_card()
+
+    # Print once to warm cache
+    start = process_time()
+    console.print(test_card)
+    pre_cache_taken = round((process_time() - start) * 1000.0, 1)
+
+    console.file = io.StringIO()
+
+    start = process_time()
+    console.print(test_card)
+    taken = round((process_time() - start) * 1000.0, 1)
+
+    c = Console(record=True)
+    c.print(test_card)
+
+    print(f"rendered in {pre_cache_taken}ms (cold cache)")
+    print(f"rendered in {taken}ms (warm cache)")
+
+    from pip._vendor.rich.panel import Panel
+
+    console = Console()
+
+    sponsor_message = Table.grid(padding=1)
+    sponsor_message.add_column(style="green", justify="right")
+    sponsor_message.add_column(no_wrap=True)
+
+    sponsor_message.add_row(
+        "Textualize",
+        "[u blue link=https://github.com/textualize]https://github.com/textualize",
+    )
+    sponsor_message.add_row(
+        "Twitter",
+        "[u blue link=https://twitter.com/willmcgugan]https://twitter.com/willmcgugan",
+    )
+
+    intro_message = Text.from_markup(
+        """\
+We hope you enjoy using Rich!
+
+Rich is maintained with [red]:heart:[/] by [link=https://www.textualize.io]Textualize.io[/]
+
+- Will McGugan"""
+    )
+
+    message = Table.grid(padding=2)
+    message.add_column()
+    message.add_column(no_wrap=True)
+    message.add_row(intro_message, sponsor_message)
+
+    console.print(
+        Panel.fit(
+            message,
+            box=box.ROUNDED,
+            padding=(1, 2),
+            title="[b red]Thanks for trying out Rich!",
+            border_style="bright_blue",
+        ),
+        justify="center",
+    )

llava/lib/python3.10/site-packages/pip/_vendor/rich/_emoji_replace.py

@@ -0,0 +1,32 @@
+from typing import Callable, Match, Optional
+import re
+
+from ._emoji_codes import EMOJI
+
+
+_ReStringMatch = Match[str]  # regex match object
+_ReSubCallable = Callable[[_ReStringMatch], str]  # Callable invoked by re.sub
+_EmojiSubMethod = Callable[[_ReSubCallable, str], str]  # Sub method of a compiled re
+
+
+def _emoji_replace(
+    text: str,
+    default_variant: Optional[str] = None,
+    _emoji_sub: _EmojiSubMethod = re.compile(r"(:(\S*?)(?:(?:\-)(emoji|text))?:)").sub,
+) -> str:
+    """Replace emoji code in text."""
+    get_emoji = EMOJI.__getitem__
+    variants = {"text": "\uFE0E", "emoji": "\uFE0F"}
+    get_variant = variants.get
+    default_variant_code = variants.get(default_variant, "") if default_variant else ""
+
+    def do_replace(match: Match[str]) -> str:
+        emoji_code, emoji_name, variant = match.groups()
+        try:
+            return get_emoji(emoji_name.lower()) + get_variant(
+                variant, default_variant_code
+            )
+        except KeyError:
+            return emoji_code
+
+    return _emoji_sub(do_replace, text)

llava/lib/python3.10/site-packages/pip/_vendor/rich/_log_render.py

@@ -0,0 +1,94 @@
+from datetime import datetime
+from typing import Iterable, List, Optional, TYPE_CHECKING, Union, Callable
+
+
+from .text import Text, TextType
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleRenderable, RenderableType
+    from .table import Table
+
+FormatTimeCallable = Callable[[datetime], Text]
+
+
+class LogRender:
+    def __init__(
+        self,
+        show_time: bool = True,
+        show_level: bool = False,
+        show_path: bool = True,
+        time_format: Union[str, FormatTimeCallable] = "[%x %X]",
+        omit_repeated_times: bool = True,
+        level_width: Optional[int] = 8,
+    ) -> None:
+        self.show_time = show_time
+        self.show_level = show_level
+        self.show_path = show_path
+        self.time_format = time_format
+        self.omit_repeated_times = omit_repeated_times
+        self.level_width = level_width
+        self._last_time: Optional[Text] = None
+
+    def __call__(
+        self,
+        console: "Console",
+        renderables: Iterable["ConsoleRenderable"],
+        log_time: Optional[datetime] = None,
+        time_format: Optional[Union[str, FormatTimeCallable]] = None,
+        level: TextType = "",
+        path: Optional[str] = None,
+        line_no: Optional[int] = None,
+        link_path: Optional[str] = None,
+    ) -> "Table":
+        from .containers import Renderables
+        from .table import Table
+
+        output = Table.grid(padding=(0, 1))
+        output.expand = True
+        if self.show_time:
+            output.add_column(style="log.time")
+        if self.show_level:
+            output.add_column(style="log.level", width=self.level_width)
+        output.add_column(ratio=1, style="log.message", overflow="fold")
+        if self.show_path and path:
+            output.add_column(style="log.path")
+        row: List["RenderableType"] = []
+        if self.show_time:
+            log_time = log_time or console.get_datetime()
+            time_format = time_format or self.time_format
+            if callable(time_format):
+                log_time_display = time_format(log_time)
+            else:
+                log_time_display = Text(log_time.strftime(time_format))
+            if log_time_display == self._last_time and self.omit_repeated_times:
+                row.append(Text(" " * len(log_time_display)))
+            else:
+                row.append(log_time_display)
+                self._last_time = log_time_display
+        if self.show_level:
+            row.append(level)
+
+        row.append(Renderables(renderables))
+        if self.show_path and path:
+            path_text = Text()
+            path_text.append(
+                path, style=f"link file://{link_path}" if link_path else ""
+            )
+            if line_no:
+                path_text.append(":")
+                path_text.append(
+                    f"{line_no}",
+                    style=f"link file://{link_path}#{line_no}" if link_path else "",
+                )
+            row.append(path_text)
+
+        output.add_row(*row)
+        return output
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.console import Console
+
+    c = Console()
+    c.print("[on blue]Hello", justify="right")
+    c.log("[on blue]hello", justify="right")

llava/lib/python3.10/site-packages/pip/_vendor/rich/_loop.py

@@ -0,0 +1,43 @@
+from typing import Iterable, Tuple, TypeVar
+
+T = TypeVar("T")
+
+
+def loop_first(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for first value."""
+    iter_values = iter(values)
+    try:
+        value = next(iter_values)
+    except StopIteration:
+        return
+    yield True, value
+    for value in iter_values:
+        yield False, value
+
+
+def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value
+
+
+def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[bool, bool, T]]:
+    """Iterate and generate a tuple with a flag for first and last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    first = True
+    for value in iter_values:
+        yield first, False, previous_value
+        first = False
+        previous_value = value
+    yield first, True, previous_value

llava/lib/python3.10/site-packages/pip/_vendor/rich/_palettes.py

@@ -0,0 +1,309 @@
+from .palette import Palette
+
+
+# Taken from https://en.wikipedia.org/wiki/ANSI_escape_code (Windows 10 column)
+WINDOWS_PALETTE = Palette(
+    [
+        (12, 12, 12),
+        (197, 15, 31),
+        (19, 161, 14),
+        (193, 156, 0),
+        (0, 55, 218),
+        (136, 23, 152),
+        (58, 150, 221),
+        (204, 204, 204),
+        (118, 118, 118),
+        (231, 72, 86),
+        (22, 198, 12),
+        (249, 241, 165),
+        (59, 120, 255),
+        (180, 0, 158),
+        (97, 214, 214),
+        (242, 242, 242),
+    ]
+)
+
+# # The standard ansi colors (including bright variants)
+STANDARD_PALETTE = Palette(
+    [
+        (0, 0, 0),
+        (170, 0, 0),
+        (0, 170, 0),
+        (170, 85, 0),
+        (0, 0, 170),
+        (170, 0, 170),
+        (0, 170, 170),
+        (170, 170, 170),
+        (85, 85, 85),
+        (255, 85, 85),
+        (85, 255, 85),
+        (255, 255, 85),
+        (85, 85, 255),
+        (255, 85, 255),
+        (85, 255, 255),
+        (255, 255, 255),
+    ]
+)
+
+
+# The 256 color palette
+EIGHT_BIT_PALETTE = Palette(
+    [
+        (0, 0, 0),
+        (128, 0, 0),
+        (0, 128, 0),
+        (128, 128, 0),
+        (0, 0, 128),
+        (128, 0, 128),
+        (0, 128, 128),
+        (192, 192, 192),
+        (128, 128, 128),
+        (255, 0, 0),
+        (0, 255, 0),
+        (255, 255, 0),
+        (0, 0, 255),
+        (255, 0, 255),
+        (0, 255, 255),
+        (255, 255, 255),
+        (0, 0, 0),
+        (0, 0, 95),
+        (0, 0, 135),
+        (0, 0, 175),
+        (0, 0, 215),
+        (0, 0, 255),
+        (0, 95, 0),
+        (0, 95, 95),
+        (0, 95, 135),
+        (0, 95, 175),
+        (0, 95, 215),
+        (0, 95, 255),
+        (0, 135, 0),
+        (0, 135, 95),
+        (0, 135, 135),
+        (0, 135, 175),
+        (0, 135, 215),
+        (0, 135, 255),
+        (0, 175, 0),
+        (0, 175, 95),
+        (0, 175, 135),
+        (0, 175, 175),
+        (0, 175, 215),
+        (0, 175, 255),
+        (0, 215, 0),
+        (0, 215, 95),
+        (0, 215, 135),
+        (0, 215, 175),
+        (0, 215, 215),
+        (0, 215, 255),
+        (0, 255, 0),
+        (0, 255, 95),
+        (0, 255, 135),
+        (0, 255, 175),
+        (0, 255, 215),
+        (0, 255, 255),
+        (95, 0, 0),
+        (95, 0, 95),
+        (95, 0, 135),
+        (95, 0, 175),
+        (95, 0, 215),
+        (95, 0, 255),
+        (95, 95, 0),
+        (95, 95, 95),
+        (95, 95, 135),
+        (95, 95, 175),
+        (95, 95, 215),
+        (95, 95, 255),
+        (95, 135, 0),
+        (95, 135, 95),
+        (95, 135, 135),
+        (95, 135, 175),
+        (95, 135, 215),
+        (95, 135, 255),
+        (95, 175, 0),
+        (95, 175, 95),
+        (95, 175, 135),
+        (95, 175, 175),
+        (95, 175, 215),
+        (95, 175, 255),
+        (95, 215, 0),
+        (95, 215, 95),
+        (95, 215, 135),
+        (95, 215, 175),
+        (95, 215, 215),
+        (95, 215, 255),
+        (95, 255, 0),
+        (95, 255, 95),
+        (95, 255, 135),
+        (95, 255, 175),
+        (95, 255, 215),
+        (95, 255, 255),
+        (135, 0, 0),
+        (135, 0, 95),
+        (135, 0, 135),
+        (135, 0, 175),
+        (135, 0, 215),
+        (135, 0, 255),
+        (135, 95, 0),
+        (135, 95, 95),
+        (135, 95, 135),
+        (135, 95, 175),
+        (135, 95, 215),
+        (135, 95, 255),
+        (135, 135, 0),
+        (135, 135, 95),
+        (135, 135, 135),
+        (135, 135, 175),
+        (135, 135, 215),
+        (135, 135, 255),
+        (135, 175, 0),
+        (135, 175, 95),
+        (135, 175, 135),
+        (135, 175, 175),
+        (135, 175, 215),
+        (135, 175, 255),
+        (135, 215, 0),
+        (135, 215, 95),
+        (135, 215, 135),
+        (135, 215, 175),
+        (135, 215, 215),
+        (135, 215, 255),
+        (135, 255, 0),
+        (135, 255, 95),
+        (135, 255, 135),
+        (135, 255, 175),
+        (135, 255, 215),
+        (135, 255, 255),
+        (175, 0, 0),
+        (175, 0, 95),
+        (175, 0, 135),
+        (175, 0, 175),
+        (175, 0, 215),
+        (175, 0, 255),
+        (175, 95, 0),
+        (175, 95, 95),
+        (175, 95, 135),
+        (175, 95, 175),
+        (175, 95, 215),
+        (175, 95, 255),
+        (175, 135, 0),
+        (175, 135, 95),
+        (175, 135, 135),
+        (175, 135, 175),
+        (175, 135, 215),
+        (175, 135, 255),
+        (175, 175, 0),
+        (175, 175, 95),
+        (175, 175, 135),
+        (175, 175, 175),
+        (175, 175, 215),
+        (175, 175, 255),
+        (175, 215, 0),
+        (175, 215, 95),
+        (175, 215, 135),
+        (175, 215, 175),
+        (175, 215, 215),
+        (175, 215, 255),
+        (175, 255, 0),
+        (175, 255, 95),
+        (175, 255, 135),
+        (175, 255, 175),
+        (175, 255, 215),
+        (175, 255, 255),
+        (215, 0, 0),
+        (215, 0, 95),
+        (215, 0, 135),
+        (215, 0, 175),
+        (215, 0, 215),
+        (215, 0, 255),
+        (215, 95, 0),
+        (215, 95, 95),
+        (215, 95, 135),
+        (215, 95, 175),
+        (215, 95, 215),
+        (215, 95, 255),
+        (215, 135, 0),
+        (215, 135, 95),
+        (215, 135, 135),
+        (215, 135, 175),
+        (215, 135, 215),
+        (215, 135, 255),
+        (215, 175, 0),
+        (215, 175, 95),
+        (215, 175, 135),
+        (215, 175, 175),
+        (215, 175, 215),
+        (215, 175, 255),
+        (215, 215, 0),
+        (215, 215, 95),
+        (215, 215, 135),
+        (215, 215, 175),
+        (215, 215, 215),
+        (215, 215, 255),
+        (215, 255, 0),
+        (215, 255, 95),
+        (215, 255, 135),
+        (215, 255, 175),
+        (215, 255, 215),
+        (215, 255, 255),
+        (255, 0, 0),
+        (255, 0, 95),
+        (255, 0, 135),
+        (255, 0, 175),
+        (255, 0, 215),
+        (255, 0, 255),
+        (255, 95, 0),
+        (255, 95, 95),
+        (255, 95, 135),
+        (255, 95, 175),
+        (255, 95, 215),
+        (255, 95, 255),
+        (255, 135, 0),
+        (255, 135, 95),
+        (255, 135, 135),
+        (255, 135, 175),
+        (255, 135, 215),
+        (255, 135, 255),
+        (255, 175, 0),
+        (255, 175, 95),
+        (255, 175, 135),
+        (255, 175, 175),
+        (255, 175, 215),
+        (255, 175, 255),
+        (255, 215, 0),
+        (255, 215, 95),
+        (255, 215, 135),
+        (255, 215, 175),
+        (255, 215, 215),
+        (255, 215, 255),
+        (255, 255, 0),
+        (255, 255, 95),
+        (255, 255, 135),
+        (255, 255, 175),
+        (255, 255, 215),
+        (255, 255, 255),
+        (8, 8, 8),
+        (18, 18, 18),
+        (28, 28, 28),
+        (38, 38, 38),
+        (48, 48, 48),
+        (58, 58, 58),
+        (68, 68, 68),
+        (78, 78, 78),
+        (88, 88, 88),
+        (98, 98, 98),
+        (108, 108, 108),
+        (118, 118, 118),
+        (128, 128, 128),
+        (138, 138, 138),
+        (148, 148, 148),
+        (158, 158, 158),
+        (168, 168, 168),
+        (178, 178, 178),
+        (188, 188, 188),
+        (198, 198, 198),
+        (208, 208, 208),
+        (218, 218, 218),
+        (228, 228, 228),
+        (238, 238, 238),
+    ]
+)

llava/lib/python3.10/site-packages/pip/_vendor/rich/_spinners.py

@@ -0,0 +1,482 @@
+"""
+Spinners are from:
+* cli-spinners:
+    MIT License
+    Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+    the Software, and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+    PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+    FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+"""
+
+SPINNERS = {
+    "dots": {
+        "interval": 80,
+        "frames": "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏",
+    },
+    "dots2": {"interval": 80, "frames": "⣾⣽⣻⢿⡿⣟⣯⣷"},
+    "dots3": {
+        "interval": 80,
+        "frames": "⠋⠙⠚⠞⠖⠦⠴⠲⠳⠓",
+    },
+    "dots4": {
+        "interval": 80,
+        "frames": "⠄⠆⠇⠋⠙⠸⠰⠠⠰⠸⠙⠋⠇⠆",
+    },
+    "dots5": {
+        "interval": 80,
+        "frames": "⠋⠙⠚⠒⠂⠂⠒⠲⠴⠦⠖⠒⠐⠐⠒⠓⠋",
+    },
+    "dots6": {
+        "interval": 80,
+        "frames": "⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠴⠲⠒⠂⠂⠒⠚⠙⠉⠁",
+    },
+    "dots7": {
+        "interval": 80,
+        "frames": "⠈⠉⠋⠓⠒⠐⠐⠒⠖⠦⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈",
+    },
+    "dots8": {
+        "interval": 80,
+        "frames": "⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈",
+    },
+    "dots9": {"interval": 80, "frames": "⢹⢺⢼⣸⣇⡧⡗⡏"},
+    "dots10": {"interval": 80, "frames": "⢄⢂⢁⡁⡈⡐⡠"},
+    "dots11": {"interval": 100, "frames": "⠁⠂⠄⡀⢀⠠⠐⠈"},
+    "dots12": {
+        "interval": 80,
+        "frames": [
+            "⢀⠀",
+            "⡀⠀",
+            "⠄⠀",
+            "⢂⠀",
+            "⡂⠀",
+            "⠅⠀",
+            "⢃⠀",
+            "⡃⠀",
+            "⠍⠀",
+            "⢋⠀",
+            "⡋⠀",
+            "⠍⠁",
+            "⢋⠁",
+            "⡋⠁",
+            "⠍⠉",
+            "⠋⠉",
+            "⠋⠉",
+            "⠉⠙",
+            "⠉⠙",
+            "⠉⠩",
+            "⠈⢙",
+            "⠈⡙",
+            "⢈⠩",
+            "⡀⢙",
+            "⠄⡙",
+            "⢂⠩",
+            "⡂⢘",
+            "⠅⡘",
+            "⢃⠨",
+            "⡃⢐",
+            "⠍⡐",
+            "⢋⠠",
+            "⡋⢀",
+            "⠍⡁",
+            "⢋⠁",
+            "⡋⠁",
+            "⠍⠉",
+            "⠋⠉",
+            "⠋⠉",
+            "⠉⠙",
+            "⠉⠙",
+            "⠉⠩",
+            "⠈⢙",
+            "⠈⡙",
+            "⠈⠩",
+            "⠀⢙",
+            "⠀⡙",
+            "⠀⠩",
+            "⠀⢘",
+            "⠀⡘",
+            "⠀⠨",
+            "⠀⢐",
+            "⠀⡐",
+            "⠀⠠",
+            "⠀⢀",
+            "⠀⡀",
+        ],
+    },
+    "dots8Bit": {
+        "interval": 80,
+        "frames": "⠀⠁⠂⠃⠄⠅⠆⠇⡀⡁⡂⡃⡄⡅⡆⡇⠈⠉⠊⠋⠌⠍⠎⠏⡈⡉⡊⡋⡌⡍⡎⡏⠐⠑⠒⠓⠔⠕⠖⠗⡐⡑⡒⡓⡔⡕⡖⡗⠘⠙⠚⠛⠜⠝⠞⠟⡘⡙"
+        "⡚⡛⡜⡝⡞⡟⠠⠡⠢⠣⠤⠥⠦⠧⡠⡡⡢⡣⡤⡥⡦⡧⠨⠩⠪⠫⠬⠭⠮⠯⡨⡩⡪⡫⡬⡭⡮⡯⠰⠱⠲⠳⠴⠵⠶⠷⡰⡱⡲⡳⡴⡵⡶⡷⠸⠹⠺⠻"
+        "⠼⠽⠾⠿⡸⡹⡺⡻⡼⡽⡾⡿⢀⢁⢂⢃⢄⢅⢆⢇⣀⣁⣂⣃⣄⣅⣆⣇⢈⢉⢊⢋⢌⢍⢎⢏⣈⣉⣊⣋⣌⣍⣎⣏⢐⢑⢒⢓⢔⢕⢖⢗⣐⣑⣒⣓⣔⣕"
+        "⣖⣗⢘⢙⢚⢛⢜⢝⢞⢟⣘⣙⣚⣛⣜⣝⣞⣟⢠⢡⢢⢣⢤⢥⢦⢧⣠⣡⣢⣣⣤⣥⣦⣧⢨⢩⢪⢫⢬⢭⢮⢯⣨⣩⣪⣫⣬⣭⣮⣯⢰⢱⢲⢳⢴⢵⢶⢷"
+        "⣰⣱⣲⣳⣴⣵⣶⣷⢸⢹⢺⢻⢼⢽⢾⢿⣸⣹⣺⣻⣼⣽⣾⣿",
+    },
+    "line": {"interval": 130, "frames": ["-", "\\", "|", "/"]},
+    "line2": {"interval": 100, "frames": "⠂-–—–-"},
+    "pipe": {"interval": 100, "frames": "┤┘┴└├┌┬┐"},
+    "simpleDots": {"interval": 400, "frames": [".  ", ".. ", "...", "   "]},
+    "simpleDotsScrolling": {
+        "interval": 200,
+        "frames": [".  ", ".. ", "...", " ..", "  .", "   "],
+    },
+    "star": {"interval": 70, "frames": "✶✸✹✺✹✷"},
+    "star2": {"interval": 80, "frames": "+x*"},
+    "flip": {
+        "interval": 70,
+        "frames": "___-``'´-___",
+    },
+    "hamburger": {"interval": 100, "frames": "☱☲☴"},
+    "growVertical": {
+        "interval": 120,
+        "frames": "▁▃▄▅▆▇▆▅▄▃",
+    },
+    "growHorizontal": {
+        "interval": 120,
+        "frames": "▏▎▍▌▋▊▉▊▋▌▍▎",
+    },
+    "balloon": {"interval": 140, "frames": " .oO@* "},
+    "balloon2": {"interval": 120, "frames": ".oO°Oo."},
+    "noise": {"interval": 100, "frames": "▓▒░"},
+    "bounce": {"interval": 120, "frames": "⠁⠂⠄⠂"},
+    "boxBounce": {"interval": 120, "frames": "▖▘▝▗"},
+    "boxBounce2": {"interval": 100, "frames": "▌▀▐▄"},
+    "triangle": {"interval": 50, "frames": "◢◣◤◥"},
+    "arc": {"interval": 100, "frames": "◜◠◝◞◡◟"},
+    "circle": {"interval": 120, "frames": "◡⊙◠"},
+    "squareCorners": {"interval": 180, "frames": "◰◳◲◱"},
+    "circleQuarters": {"interval": 120, "frames": "◴◷◶◵"},
+    "circleHalves": {"interval": 50, "frames": "◐◓◑◒"},
+    "squish": {"interval": 100, "frames": "╫╪"},
+    "toggle": {"interval": 250, "frames": "⊶⊷"},
+    "toggle2": {"interval": 80, "frames": "▫▪"},
+    "toggle3": {"interval": 120, "frames": "□■"},
+    "toggle4": {"interval": 100, "frames": "■□▪▫"},
+    "toggle5": {"interval": 100, "frames": "▮▯"},
+    "toggle6": {"interval": 300, "frames": "ဝ၀"},
+    "toggle7": {"interval": 80, "frames": "⦾⦿"},
+    "toggle8": {"interval": 100, "frames": "◍◌"},
+    "toggle9": {"interval": 100, "frames": "◉◎"},
+    "toggle10": {"interval": 100, "frames": "㊂㊀㊁"},
+    "toggle11": {"interval": 50, "frames": "⧇⧆"},
+    "toggle12": {"interval": 120, "frames": "☗☖"},
+    "toggle13": {"interval": 80, "frames": "=*-"},
+    "arrow": {"interval": 100, "frames": "←↖↑↗→↘↓↙"},
+    "arrow2": {
+        "interval": 80,
+        "frames": ["⬆️ ", "↗️ ", "➡️ ", "↘️ ", "⬇️ ", "↙️ ", "⬅️ ", "↖️ "],
+    },
+    "arrow3": {
+        "interval": 120,
+        "frames": ["▹▹▹▹▹", "▸▹▹▹▹", "▹▸▹▹▹", "▹▹▸▹▹", "▹▹▹▸▹", "▹▹▹▹▸"],
+    },
+    "bouncingBar": {
+        "interval": 80,
+        "frames": [
+            "[    ]",
+            "[=   ]",
+            "[==  ]",
+            "[=== ]",
+            "[ ===]",
+            "[  ==]",
+            "[   =]",
+            "[    ]",
+            "[   =]",
+            "[  ==]",
+            "[ ===]",
+            "[====]",
+            "[=== ]",
+            "[==  ]",
+            "[=   ]",
+        ],
+    },
+    "bouncingBall": {
+        "interval": 80,
+        "frames": [
+            "( ●    )",
+            "(  ●   )",
+            "(   ●  )",
+            "(    ● )",
+            "(     ●)",
+            "(    ● )",
+            "(   ●  )",
+            "(  ●   )",
+            "( ●    )",
+            "(●     )",
+        ],
+    },
+    "smiley": {"interval": 200, "frames": ["😄 ", "😝 "]},
+    "monkey": {"interval": 300, "frames": ["🙈 ", "🙈 ", "🙉 ", "🙊 "]},
+    "hearts": {"interval": 100, "frames": ["💛 ", "💙 ", "💜 ", "💚 ", "❤️ "]},
+    "clock": {
+        "interval": 100,
+        "frames": [
+            "🕛 ",
+            "🕐 ",
+            "🕑 ",
+            "🕒 ",
+            "🕓 ",
+            "🕔 ",
+            "🕕 ",
+            "🕖 ",
+            "🕗 ",
+            "🕘 ",
+            "🕙 ",
+            "🕚 ",
+        ],
+    },
+    "earth": {"interval": 180, "frames": ["🌍 ", "🌎 ", "🌏 "]},
+    "material": {
+        "interval": 17,
+        "frames": [
+            "█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "███▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "████▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "███████▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "████████▁▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "██████████▁▁▁▁▁▁▁▁▁▁",
+            "███████████▁▁▁▁▁▁▁▁▁",
+            "█████████████▁▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁▁██████████████▁▁▁▁",
+            "▁▁▁██████████████▁▁▁",
+            "▁▁▁▁█████████████▁▁▁",
+            "▁▁▁▁██████████████▁▁",
+            "▁▁▁▁██████████████▁▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁▁██████████████",
+            "▁▁▁▁▁▁██████████████",
+            "▁▁▁▁▁▁▁█████████████",
+            "▁▁▁▁▁▁▁█████████████",
+            "▁▁▁▁▁▁▁▁████████████",
+            "▁▁▁▁▁▁▁▁████████████",
+            "▁▁▁▁▁▁▁▁▁███████████",
+            "▁▁▁▁▁▁▁▁▁███████████",
+            "▁▁▁▁▁▁▁▁▁▁██████████",
+            "▁▁▁▁▁▁▁▁▁▁██████████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁████████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁██████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "███▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "████▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "████████▁▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "███████████▁▁▁▁▁▁▁▁▁",
+            "████████████▁▁▁▁▁▁▁▁",
+            "████████████▁▁▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁▁▁█████████████▁▁▁▁",
+            "▁▁▁▁▁████████████▁▁▁",
+            "▁▁▁▁▁████████████▁▁▁",
+            "▁▁▁▁▁▁███████████▁▁▁",
+            "▁▁▁▁▁▁▁▁█████████▁▁▁",
+            "▁▁▁▁▁▁▁▁█████████▁▁▁",
+            "▁▁▁▁▁▁▁▁▁█████████▁▁",
+            "▁▁▁▁▁▁▁▁▁█████████▁▁",
+            "▁▁▁▁▁▁▁▁▁▁█████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+        ],
+    },
+    "moon": {
+        "interval": 80,
+        "frames": ["🌑 ", "🌒 ", "🌓 ", "🌔 ", "🌕 ", "🌖 ", "🌗 ", "🌘 "],
+    },
+    "runner": {"interval": 140, "frames": ["🚶 ", "🏃 "]},
+    "pong": {
+        "interval": 80,
+        "frames": [
+            "▐⠂       ▌",
+            "▐⠈       ▌",
+            "▐ ⠂      ▌",
+            "▐ ⠠      ▌",
+            "▐  ⡀     ▌",
+            "▐  ⠠     ▌",
+            "▐   ⠂    ▌",
+            "▐   ⠈    ▌",
+            "▐    ⠂   ▌",
+            "▐    ⠠   ▌",
+            "▐     ⡀  ▌",
+            "▐     ⠠  ▌",
+            "▐      ⠂ ▌",
+            "▐      ⠈ ▌",
+            "▐       ⠂▌",
+            "▐       ⠠▌",
+            "▐       ⡀▌",
+            "▐      ⠠ ▌",
+            "▐      ⠂ ▌",
+            "▐     ⠈  ▌",
+            "▐     ⠂  ▌",
+            "▐    ⠠   ▌",
+            "▐    ⡀   ▌",
+            "▐   ⠠    ▌",
+            "▐   ⠂    ▌",
+            "▐  ⠈     ▌",
+            "▐  ⠂     ▌",
+            "▐ ⠠      ▌",
+            "▐ ⡀      ▌",
+            "▐⠠       ▌",
+        ],
+    },
+    "shark": {
+        "interval": 120,
+        "frames": [
+            "▐|\\____________▌",
+            "▐_|\\___________▌",
+            "▐__|\\__________▌",
+            "▐___|\\_________▌",
+            "▐____|\\________▌",
+            "▐_____|\\_______▌",
+            "▐______|\\______▌",
+            "▐_______|\\_____▌",
+            "▐________|\\____▌",
+            "▐_________|\\___▌",
+            "▐__________|\\__▌",
+            "▐___________|\\_▌",
+            "▐____________|\\▌",
+            "▐____________/|▌",
+            "▐___________/|_▌",
+            "▐__________/|__▌",
+            "▐_________/|___▌",
+            "▐________/|____▌",
+            "▐_______/|_____▌",
+            "▐______/|______▌",
+            "▐_____/|_______▌",
+            "▐____/|________▌",
+            "▐___/|_________▌",
+            "▐__/|__________▌",
+            "▐_/|___________▌",
+            "▐/|____________▌",
+        ],
+    },
+    "dqpb": {"interval": 100, "frames": "dqpb"},
+    "weather": {
+        "interval": 100,
+        "frames": [
+            "☀️ ",
+            "☀️ ",
+            "☀️ ",
+            "🌤 ",
+            "⛅️ ",
+            "🌥 ",
+            "☁️ ",
+            "🌧 ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "⛈ ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "☁️ ",
+            "🌥 ",
+            "⛅️ ",
+            "🌤 ",
+            "☀️ ",
+            "☀️ ",
+        ],
+    },
+    "christmas": {"interval": 400, "frames": "🌲🎄"},
+    "grenade": {
+        "interval": 80,
+        "frames": [
+            "،   ",
+            "′   ",
+            " ´ ",
+            " ‾ ",
+            "  ⸌",
+            "  ⸊",
+            "  |",
+            "  ⁎",
+            "  ⁕",
+            " ෴ ",
+            "  ⁓",
+            "   ",
+            "   ",
+            "   ",
+        ],
+    },
+    "point": {"interval": 125, "frames": ["∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"]},
+    "layer": {"interval": 150, "frames": "-=≡"},
+    "betaWave": {
+        "interval": 80,
+        "frames": [
+            "ρββββββ",
+            "βρβββββ",
+            "ββρββββ",
+            "βββρβββ",
+            "ββββρββ",
+            "βββββρβ",
+            "ββββββρ",
+        ],
+    },
+    "aesthetic": {
+        "interval": 80,
+        "frames": [
+            "▰▱▱▱▱▱▱",
+            "▰▰▱▱▱▱▱",
+            "▰▰▰▱▱▱▱",
+            "▰▰▰▰▱▱▱",
+            "▰▰▰▰▰▱▱",
+            "▰▰▰▰▰▰▱",
+            "▰▰▰▰▰▰▰",
+            "▰▱▱▱▱▱▱",
+        ],
+    },
+}

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

@@ -0,0 +1,16 @@
+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)

llava/lib/python3.10/site-packages/pip/_vendor/rich/ansi.py

@@ -0,0 +1,241 @@
+import re
+import sys
+from contextlib import suppress
+from typing import Iterable, NamedTuple, Optional
+
+from .color import Color
+from .style import Style
+from .text import Text
+
+re_ansi = re.compile(
+    r"""
+(?:\x1b[0-?])|
+(?:\x1b\](.*?)\x1b\\)|
+(?:\x1b([(@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))
+""",
+    re.VERBOSE,
+)
+
+
+class _AnsiToken(NamedTuple):
+    """Result of ansi tokenized string."""
+
+    plain: str = ""
+    sgr: Optional[str] = ""
+    osc: Optional[str] = ""
+
+
+def _ansi_tokenize(ansi_text: str) -> Iterable[_AnsiToken]:
+    """Tokenize a string in to plain text and ANSI codes.
+
+    Args:
+        ansi_text (str): A String containing ANSI codes.
+
+    Yields:
+        AnsiToken: A named tuple of (plain, sgr, osc)
+    """
+
+    position = 0
+    sgr: Optional[str]
+    osc: Optional[str]
+    for match in re_ansi.finditer(ansi_text):
+        start, end = match.span(0)
+        osc, sgr = match.groups()
+        if start > position:
+            yield _AnsiToken(ansi_text[position:start])
+        if sgr:
+            if sgr == "(":
+                position = end + 1
+                continue
+            if sgr.endswith("m"):
+                yield _AnsiToken("", sgr[1:-1], osc)
+        else:
+            yield _AnsiToken("", sgr, osc)
+        position = end
+    if position < len(ansi_text):
+        yield _AnsiToken(ansi_text[position:])
+
+
+SGR_STYLE_MAP = {
+    1: "bold",
+    2: "dim",
+    3: "italic",
+    4: "underline",
+    5: "blink",
+    6: "blink2",
+    7: "reverse",
+    8: "conceal",
+    9: "strike",
+    21: "underline2",
+    22: "not dim not bold",
+    23: "not italic",
+    24: "not underline",
+    25: "not blink",
+    26: "not blink2",
+    27: "not reverse",
+    28: "not conceal",
+    29: "not strike",
+    30: "color(0)",
+    31: "color(1)",
+    32: "color(2)",
+    33: "color(3)",
+    34: "color(4)",
+    35: "color(5)",
+    36: "color(6)",
+    37: "color(7)",
+    39: "default",
+    40: "on color(0)",
+    41: "on color(1)",
+    42: "on color(2)",
+    43: "on color(3)",
+    44: "on color(4)",
+    45: "on color(5)",
+    46: "on color(6)",
+    47: "on color(7)",
+    49: "on default",
+    51: "frame",
+    52: "encircle",
+    53: "overline",
+    54: "not frame not encircle",
+    55: "not overline",
+    90: "color(8)",
+    91: "color(9)",
+    92: "color(10)",
+    93: "color(11)",
+    94: "color(12)",
+    95: "color(13)",
+    96: "color(14)",
+    97: "color(15)",
+    100: "on color(8)",
+    101: "on color(9)",
+    102: "on color(10)",
+    103: "on color(11)",
+    104: "on color(12)",
+    105: "on color(13)",
+    106: "on color(14)",
+    107: "on color(15)",
+}
+
+
+class AnsiDecoder:
+    """Translate ANSI code in to styled Text."""
+
+    def __init__(self) -> None:
+        self.style = Style.null()
+
+    def decode(self, terminal_text: str) -> Iterable[Text]:
+        """Decode ANSI codes in an iterable of lines.
+
+        Args:
+            lines (Iterable[str]): An iterable of lines of terminal output.
+
+        Yields:
+            Text: Marked up Text.
+        """
+        for line in terminal_text.splitlines():
+            yield self.decode_line(line)
+
+    def decode_line(self, line: str) -> Text:
+        """Decode a line containing ansi codes.
+
+        Args:
+            line (str): A line of terminal output.
+
+        Returns:
+            Text: A Text instance marked up according to ansi codes.
+        """
+        from_ansi = Color.from_ansi
+        from_rgb = Color.from_rgb
+        _Style = Style
+        text = Text()
+        append = text.append
+        line = line.rsplit("\r", 1)[-1]
+        for plain_text, sgr, osc in _ansi_tokenize(line):
+            if plain_text:
+                append(plain_text, self.style or None)
+            elif osc is not None:
+                if osc.startswith("8;"):
+                    _params, semicolon, link = osc[2:].partition(";")
+                    if semicolon:
+                        self.style = self.style.update_link(link or None)
+            elif sgr is not None:
+                # Translate in to semi-colon separated codes
+                # Ignore invalid codes, because we want to be lenient
+                codes = [
+                    min(255, int(_code) if _code else 0)
+                    for _code in sgr.split(";")
+                    if _code.isdigit() or _code == ""
+                ]
+                iter_codes = iter(codes)
+                for code in iter_codes:
+                    if code == 0:
+                        # reset
+                        self.style = _Style.null()
+                    elif code in SGR_STYLE_MAP:
+                        # styles
+                        self.style += _Style.parse(SGR_STYLE_MAP[code])
+                    elif code == 38:
+                        #  Foreground
+                        with suppress(StopIteration):
+                            color_type = next(iter_codes)
+                            if color_type == 5:
+                                self.style += _Style.from_color(
+                                    from_ansi(next(iter_codes))
+                                )
+                            elif color_type == 2:
+                                self.style += _Style.from_color(
+                                    from_rgb(
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                    )
+                                )
+                    elif code == 48:
+                        # Background
+                        with suppress(StopIteration):
+                            color_type = next(iter_codes)
+                            if color_type == 5:
+                                self.style += _Style.from_color(
+                                    None, from_ansi(next(iter_codes))
+                                )
+                            elif color_type == 2:
+                                self.style += _Style.from_color(
+                                    None,
+                                    from_rgb(
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                    ),
+                                )
+
+        return text
+
+
+if sys.platform != "win32" and __name__ == "__main__":  # pragma: no cover
+    import io
+    import os
+    import pty
+    import sys
+
+    decoder = AnsiDecoder()
+
+    stdout = io.BytesIO()
+
+    def read(fd: int) -> bytes:
+        data = os.read(fd, 1024)
+        stdout.write(data)
+        return data
+
+    pty.spawn(sys.argv[1:], read)
+
+    from .console import Console
+
+    console = Console(record=True)
+
+    stdout_result = stdout.getvalue().decode("utf-8")
+    print(stdout_result)
+
+    for line in decoder.decode(stdout_result):
+        console.print(line)
+
+    console.save_html("stdout.html")

llava/lib/python3.10/site-packages/pip/_vendor/rich/constrain.py

@@ -0,0 +1,37 @@
+from typing import Optional, TYPE_CHECKING
+
+from .jupyter import JupyterMixin
+from .measure import Measurement
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderableType, RenderResult
+
+
+class Constrain(JupyterMixin):
+    """Constrain the width of a renderable to a given number of characters.
+
+    Args:
+        renderable (RenderableType): A renderable object.
+        width (int, optional): The maximum width (in characters) to render. Defaults to 80.
+    """
+
+    def __init__(self, renderable: "RenderableType", width: Optional[int] = 80) -> None:
+        self.renderable = renderable
+        self.width = width
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        if self.width is None:
+            yield self.renderable
+        else:
+            child_options = options.update_width(min(self.width, options.max_width))
+            yield from console.render(self.renderable, child_options)
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        if self.width is not None:
+            options = options.update_width(self.width)
+        measurement = Measurement.get(console, options, self.renderable)
+        return measurement

llava/lib/python3.10/site-packages/pip/_vendor/rich/containers.py

@@ -0,0 +1,167 @@
+from itertools import zip_longest
+from typing import (
+    TYPE_CHECKING,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from .console import (
+        Console,
+        ConsoleOptions,
+        JustifyMethod,
+        OverflowMethod,
+        RenderResult,
+        RenderableType,
+    )
+    from .text import Text
+
+from .cells import cell_len
+from .measure import Measurement
+
+T = TypeVar("T")
+
+
+class Renderables:
+    """A list subclass which renders its contents to the console."""
+
+    def __init__(
+        self, renderables: Optional[Iterable["RenderableType"]] = None
+    ) -> None:
+        self._renderables: List["RenderableType"] = (
+            list(renderables) if renderables is not None else []
+        )
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        """Console render method to insert line-breaks."""
+        yield from self._renderables
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        dimensions = [
+            Measurement.get(console, options, renderable)
+            for renderable in self._renderables
+        ]
+        if not dimensions:
+            return Measurement(1, 1)
+        _min = max(dimension.minimum for dimension in dimensions)
+        _max = max(dimension.maximum for dimension in dimensions)
+        return Measurement(_min, _max)
+
+    def append(self, renderable: "RenderableType") -> None:
+        self._renderables.append(renderable)
+
+    def __iter__(self) -> Iterable["RenderableType"]:
+        return iter(self._renderables)
+
+
+class Lines:
+    """A list subclass which can render to the console."""
+
+    def __init__(self, lines: Iterable["Text"] = ()) -> None:
+        self._lines: List["Text"] = list(lines)
+
+    def __repr__(self) -> str:
+        return f"Lines({self._lines!r})"
+
+    def __iter__(self) -> Iterator["Text"]:
+        return iter(self._lines)
+
+    @overload
+    def __getitem__(self, index: int) -> "Text":
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> List["Text"]:
+        ...
+
+    def __getitem__(self, index: Union[slice, int]) -> Union["Text", List["Text"]]:
+        return self._lines[index]
+
+    def __setitem__(self, index: int, value: "Text") -> "Lines":
+        self._lines[index] = value
+        return self
+
+    def __len__(self) -> int:
+        return self._lines.__len__()
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        """Console render method to insert line-breaks."""
+        yield from self._lines
+
+    def append(self, line: "Text") -> None:
+        self._lines.append(line)
+
+    def extend(self, lines: Iterable["Text"]) -> None:
+        self._lines.extend(lines)
+
+    def pop(self, index: int = -1) -> "Text":
+        return self._lines.pop(index)
+
+    def justify(
+        self,
+        console: "Console",
+        width: int,
+        justify: "JustifyMethod" = "left",
+        overflow: "OverflowMethod" = "fold",
+    ) -> None:
+        """Justify and overflow text to a given width.
+
+        Args:
+            console (Console): Console instance.
+            width (int): Number of cells available per line.
+            justify (str, optional): Default justify method for text: "left", "center", "full" or "right". Defaults to "left".
+            overflow (str, optional): Default overflow for text: "crop", "fold", or "ellipsis". Defaults to "fold".
+
+        """
+        from .text import Text
+
+        if justify == "left":
+            for line in self._lines:
+                line.truncate(width, overflow=overflow, pad=True)
+        elif justify == "center":
+            for line in self._lines:
+                line.rstrip()
+                line.truncate(width, overflow=overflow)
+                line.pad_left((width - cell_len(line.plain)) // 2)
+                line.pad_right(width - cell_len(line.plain))
+        elif justify == "right":
+            for line in self._lines:
+                line.rstrip()
+                line.truncate(width, overflow=overflow)
+                line.pad_left(width - cell_len(line.plain))
+        elif justify == "full":
+            for line_index, line in enumerate(self._lines):
+                if line_index == len(self._lines) - 1:
+                    break
+                words = line.split(" ")
+                words_size = sum(cell_len(word.plain) for word in words)
+                num_spaces = len(words) - 1
+                spaces = [1 for _ in range(num_spaces)]
+                index = 0
+                if spaces:
+                    while words_size + num_spaces < width:
+                        spaces[len(spaces) - index - 1] += 1
+                        num_spaces += 1
+                        index = (index + 1) % len(spaces)
+                tokens: List[Text] = []
+                for index, (word, next_word) in enumerate(
+                    zip_longest(words, words[1:])
+                ):
+                    tokens.append(word)
+                    if index < len(spaces):
+                        style = word.get_style_at_offset(console, -1)
+                        next_style = next_word.get_style_at_offset(console, 0)
+                        space_style = style if style == next_style else line.style
+                        tokens.append(Text(" " * spaces[index], style=space_style))
+                self[line_index] = Text("").join(tokens)

llava/lib/python3.10/site-packages/pip/_vendor/rich/diagnose.py

@@ -0,0 +1,37 @@
+import os
+import platform
+
+from pip._vendor.rich import inspect
+from pip._vendor.rich.console import Console, get_windows_console_features
+from pip._vendor.rich.panel import Panel
+from pip._vendor.rich.pretty import Pretty
+
+
+def report() -> None:  # pragma: no cover
+    """Print a report to the terminal with debugging information"""
+    console = Console()
+    inspect(console)
+    features = get_windows_console_features()
+    inspect(features)
+
+    env_names = (
+        "TERM",
+        "COLORTERM",
+        "CLICOLOR",
+        "NO_COLOR",
+        "TERM_PROGRAM",
+        "COLUMNS",
+        "LINES",
+        "JUPYTER_COLUMNS",
+        "JUPYTER_LINES",
+        "JPY_PARENT_PID",
+        "VSCODE_VERBOSE_LOGGING",
+    )
+    env = {name: os.getenv(name) for name in env_names}
+    console.print(Panel.fit((Pretty(env)), title="[b]Environment Variables"))
+
+    console.print(f'platform="{platform.system()}"')
+
+
+if __name__ == "__main__":  # pragma: no cover
+    report()

llava/lib/python3.10/site-packages/pip/_vendor/rich/file_proxy.py

@@ -0,0 +1,57 @@
+import io
+from typing import IO, TYPE_CHECKING, Any, List
+
+from .ansi import AnsiDecoder
+from .text import Text
+
+if TYPE_CHECKING:
+    from .console import Console
+
+
+class FileProxy(io.TextIOBase):
+    """Wraps a file (e.g. sys.stdout) and redirects writes to a console."""
+
+    def __init__(self, console: "Console", file: IO[str]) -> None:
+        self.__console = console
+        self.__file = file
+        self.__buffer: List[str] = []
+        self.__ansi_decoder = AnsiDecoder()
+
+    @property
+    def rich_proxied_file(self) -> IO[str]:
+        """Get proxied file."""
+        return self.__file
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.__file, name)
+
+    def write(self, text: str) -> int:
+        if not isinstance(text, str):
+            raise TypeError(f"write() argument must be str, not {type(text).__name__}")
+        buffer = self.__buffer
+        lines: List[str] = []
+        while text:
+            line, new_line, text = text.partition("\n")
+            if new_line:
+                lines.append("".join(buffer) + line)
+                buffer.clear()
+            else:
+                buffer.append(line)
+                break
+        if lines:
+            console = self.__console
+            with console:
+                output = Text("\n").join(
+                    self.__ansi_decoder.decode_line(line) for line in lines
+                )
+                console.print(output)
+        return len(text)
+
+    def flush(self) -> None:
+        output = "".join(self.__buffer)
+        if output:
+            self.__console.print(output)
+        del self.__buffer[:]
+
+    def fileno(self) -> int:
+        return self.__file.fileno()

llava/lib/python3.10/site-packages/pip/_vendor/rich/filesize.py

@@ -0,0 +1,88 @@
+"""Functions for reporting filesizes. Borrowed from https://github.com/PyFilesystem/pyfilesystem2
+
+The functions declared in this module should cover the different
+use cases needed to generate a string representation of a file size
+using several different units. Since there are many standards regarding
+file size units, three different functions have been implemented.
+
+See Also:
+    * `Wikipedia: Binary prefix <https://en.wikipedia.org/wiki/Binary_prefix>`_
+
+"""
+
+__all__ = ["decimal"]
+
+from typing import Iterable, List, Optional, Tuple
+
+
+def _to_str(
+    size: int,
+    suffixes: Iterable[str],
+    base: int,
+    *,
+    precision: Optional[int] = 1,
+    separator: Optional[str] = " ",
+) -> str:
+    if size == 1:
+        return "1 byte"
+    elif size < base:
+        return f"{size:,} bytes"
+
+    for i, suffix in enumerate(suffixes, 2):  # noqa: B007
+        unit = base**i
+        if size < unit:
+            break
+    return "{:,.{precision}f}{separator}{}".format(
+        (base * size / unit),
+        suffix,
+        precision=precision,
+        separator=separator,
+    )
+
+
+def pick_unit_and_suffix(size: int, suffixes: List[str], base: int) -> Tuple[int, str]:
+    """Pick a suffix and base for the given size."""
+    for i, suffix in enumerate(suffixes):
+        unit = base**i
+        if size < unit * base:
+            break
+    return unit, suffix
+
+
+def decimal(
+    size: int,
+    *,
+    precision: Optional[int] = 1,
+    separator: Optional[str] = " ",
+) -> str:
+    """Convert a filesize in to a string (powers of 1000, SI prefixes).
+
+    In this convention, ``1000 B = 1 kB``.
+
+    This is typically the format used to advertise the storage
+    capacity of USB flash drives and the like (*256 MB* meaning
+    actually a storage capacity of more than *256 000 000 B*),
+    or used by **Mac OS X** since v10.6 to report file sizes.
+
+    Arguments:
+        int (size): A file size.
+        int (precision): The number of decimal places to include (default = 1).
+        str (separator): The string to separate the value from the units (default = " ").
+
+    Returns:
+        `str`: A string containing a abbreviated file size and units.
+
+    Example:
+        >>> filesize.decimal(30000)
+        '30.0 kB'
+        >>> filesize.decimal(30000, precision=2, separator="")
+        '30.00kB'
+
+    """
+    return _to_str(
+        size,
+        ("kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"),
+        1000,
+        precision=precision,
+        separator=separator,
+    )

llava/lib/python3.10/site-packages/pip/_vendor/rich/logging.py

@@ -0,0 +1,297 @@
+import logging
+from datetime import datetime
+from logging import Handler, LogRecord
+from pathlib import Path
+from types import ModuleType
+from typing import ClassVar, Iterable, List, Optional, Type, Union
+
+from pip._vendor.rich._null_file import NullFile
+
+from . import get_console
+from ._log_render import FormatTimeCallable, LogRender
+from .console import Console, ConsoleRenderable
+from .highlighter import Highlighter, ReprHighlighter
+from .text import Text
+from .traceback import Traceback
+
+
+class RichHandler(Handler):
+    """A logging handler that renders output with Rich. The time / level / message and file are displayed in columns.
+    The level is color coded, and the message is syntax highlighted.
+
+    Note:
+        Be careful when enabling console markup in log messages if you have configured logging for libraries not
+        under your control. If a dependency writes messages containing square brackets, it may not produce the intended output.
+
+    Args:
+        level (Union[int, str], optional): Log level. Defaults to logging.NOTSET.
+        console (:class:`~rich.console.Console`, optional): Optional console instance to write logs.
+            Default will use a global console instance writing to stdout.
+        show_time (bool, optional): Show a column for the time. Defaults to True.
+        omit_repeated_times (bool, optional): Omit repetition of the same time. Defaults to True.
+        show_level (bool, optional): Show a column for the level. Defaults to True.
+        show_path (bool, optional): Show the path to the original log call. Defaults to True.
+        enable_link_path (bool, optional): Enable terminal link of path column to file. Defaults to True.
+        highlighter (Highlighter, optional): Highlighter to style log messages, or None to use ReprHighlighter. Defaults to None.
+        markup (bool, optional): Enable console markup in log messages. Defaults to False.
+        rich_tracebacks (bool, optional): Enable rich tracebacks with syntax highlighting and formatting. Defaults to False.
+        tracebacks_width (Optional[int], optional): Number of characters used to render tracebacks, or None for full width. Defaults to None.
+        tracebacks_code_width (int, optional): Number of code characters used to render tracebacks, or None for full width. Defaults to 88.
+        tracebacks_extra_lines (int, optional): Additional lines of code to render tracebacks, or None for full width. Defaults to None.
+        tracebacks_theme (str, optional): Override pygments theme used in traceback.
+        tracebacks_word_wrap (bool, optional): Enable word wrapping of long tracebacks lines. Defaults to True.
+        tracebacks_show_locals (bool, optional): Enable display of locals in tracebacks. Defaults to False.
+        tracebacks_suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
+        tracebacks_max_frames (int, optional): Optional maximum number of frames returned by traceback.
+        locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
+            Defaults to 10.
+        locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.
+        log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to "[%x %X] ".
+        keywords (List[str], optional): List of words to highlight instead of ``RichHandler.KEYWORDS``.
+    """
+
+    KEYWORDS: ClassVar[Optional[List[str]]] = [
+        "GET",
+        "POST",
+        "HEAD",
+        "PUT",
+        "DELETE",
+        "OPTIONS",
+        "TRACE",
+        "PATCH",
+    ]
+    HIGHLIGHTER_CLASS: ClassVar[Type[Highlighter]] = ReprHighlighter
+
+    def __init__(
+        self,
+        level: Union[int, str] = logging.NOTSET,
+        console: Optional[Console] = None,
+        *,
+        show_time: bool = True,
+        omit_repeated_times: bool = True,
+        show_level: bool = True,
+        show_path: bool = True,
+        enable_link_path: bool = True,
+        highlighter: Optional[Highlighter] = None,
+        markup: bool = False,
+        rich_tracebacks: bool = False,
+        tracebacks_width: Optional[int] = None,
+        tracebacks_code_width: int = 88,
+        tracebacks_extra_lines: int = 3,
+        tracebacks_theme: Optional[str] = None,
+        tracebacks_word_wrap: bool = True,
+        tracebacks_show_locals: bool = False,
+        tracebacks_suppress: Iterable[Union[str, ModuleType]] = (),
+        tracebacks_max_frames: int = 100,
+        locals_max_length: int = 10,
+        locals_max_string: int = 80,
+        log_time_format: Union[str, FormatTimeCallable] = "[%x %X]",
+        keywords: Optional[List[str]] = None,
+    ) -> None:
+        super().__init__(level=level)
+        self.console = console or get_console()
+        self.highlighter = highlighter or self.HIGHLIGHTER_CLASS()
+        self._log_render = LogRender(
+            show_time=show_time,
+            show_level=show_level,
+            show_path=show_path,
+            time_format=log_time_format,
+            omit_repeated_times=omit_repeated_times,
+            level_width=None,
+        )
+        self.enable_link_path = enable_link_path
+        self.markup = markup
+        self.rich_tracebacks = rich_tracebacks
+        self.tracebacks_width = tracebacks_width
+        self.tracebacks_extra_lines = tracebacks_extra_lines
+        self.tracebacks_theme = tracebacks_theme
+        self.tracebacks_word_wrap = tracebacks_word_wrap
+        self.tracebacks_show_locals = tracebacks_show_locals
+        self.tracebacks_suppress = tracebacks_suppress
+        self.tracebacks_max_frames = tracebacks_max_frames
+        self.tracebacks_code_width = tracebacks_code_width
+        self.locals_max_length = locals_max_length
+        self.locals_max_string = locals_max_string
+        self.keywords = keywords
+
+    def get_level_text(self, record: LogRecord) -> Text:
+        """Get the level name from the record.
+
+        Args:
+            record (LogRecord): LogRecord instance.
+
+        Returns:
+            Text: A tuple of the style and level name.
+        """
+        level_name = record.levelname
+        level_text = Text.styled(
+            level_name.ljust(8), f"logging.level.{level_name.lower()}"
+        )
+        return level_text
+
+    def emit(self, record: LogRecord) -> None:
+        """Invoked by logging."""
+        message = self.format(record)
+        traceback = None
+        if (
+            self.rich_tracebacks
+            and record.exc_info
+            and record.exc_info != (None, None, None)
+        ):
+            exc_type, exc_value, exc_traceback = record.exc_info
+            assert exc_type is not None
+            assert exc_value is not None
+            traceback = Traceback.from_exception(
+                exc_type,
+                exc_value,
+                exc_traceback,
+                width=self.tracebacks_width,
+                code_width=self.tracebacks_code_width,
+                extra_lines=self.tracebacks_extra_lines,
+                theme=self.tracebacks_theme,
+                word_wrap=self.tracebacks_word_wrap,
+                show_locals=self.tracebacks_show_locals,
+                locals_max_length=self.locals_max_length,
+                locals_max_string=self.locals_max_string,
+                suppress=self.tracebacks_suppress,
+                max_frames=self.tracebacks_max_frames,
+            )
+            message = record.getMessage()
+            if self.formatter:
+                record.message = record.getMessage()
+                formatter = self.formatter
+                if hasattr(formatter, "usesTime") and formatter.usesTime():
+                    record.asctime = formatter.formatTime(record, formatter.datefmt)
+                message = formatter.formatMessage(record)
+
+        message_renderable = self.render_message(record, message)
+        log_renderable = self.render(
+            record=record, traceback=traceback, message_renderable=message_renderable
+        )
+        if isinstance(self.console.file, NullFile):
+            # Handles pythonw, where stdout/stderr are null, and we return NullFile
+            # instance from Console.file. In this case, we still want to make a log record
+            # even though we won't be writing anything to a file.
+            self.handleError(record)
+        else:
+            try:
+                self.console.print(log_renderable)
+            except Exception:
+                self.handleError(record)
+
+    def render_message(self, record: LogRecord, message: str) -> "ConsoleRenderable":
+        """Render message text in to Text.
+
+        Args:
+            record (LogRecord): logging Record.
+            message (str): String containing log message.
+
+        Returns:
+            ConsoleRenderable: Renderable to display log message.
+        """
+        use_markup = getattr(record, "markup", self.markup)
+        message_text = Text.from_markup(message) if use_markup else Text(message)
+
+        highlighter = getattr(record, "highlighter", self.highlighter)
+        if highlighter:
+            message_text = highlighter(message_text)
+
+        if self.keywords is None:
+            self.keywords = self.KEYWORDS
+
+        if self.keywords:
+            message_text.highlight_words(self.keywords, "logging.keyword")
+
+        return message_text
+
+    def render(
+        self,
+        *,
+        record: LogRecord,
+        traceback: Optional[Traceback],
+        message_renderable: "ConsoleRenderable",
+    ) -> "ConsoleRenderable":
+        """Render log for display.
+
+        Args:
+            record (LogRecord): logging Record.
+            traceback (Optional[Traceback]): Traceback instance or None for no Traceback.
+            message_renderable (ConsoleRenderable): Renderable (typically Text) containing log message contents.
+
+        Returns:
+            ConsoleRenderable: Renderable to display log.
+        """
+        path = Path(record.pathname).name
+        level = self.get_level_text(record)
+        time_format = None if self.formatter is None else self.formatter.datefmt
+        log_time = datetime.fromtimestamp(record.created)
+
+        log_renderable = self._log_render(
+            self.console,
+            [message_renderable] if not traceback else [message_renderable, traceback],
+            log_time=log_time,
+            time_format=time_format,
+            level=level,
+            path=path,
+            line_no=record.lineno,
+            link_path=record.pathname if self.enable_link_path else None,
+        )
+        return log_renderable
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from time import sleep
+
+    FORMAT = "%(message)s"
+    # FORMAT = "%(asctime)-15s - %(levelname)s - %(message)s"
+    logging.basicConfig(
+        level="NOTSET",
+        format=FORMAT,
+        datefmt="[%X]",
+        handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)],
+    )
+    log = logging.getLogger("rich")
+
+    log.info("Server starting...")
+    log.info("Listening on http://127.0.0.1:8080")
+    sleep(1)
+
+    log.info("GET /index.html 200 1298")
+    log.info("GET /imgs/backgrounds/back1.jpg 200 54386")
+    log.info("GET /css/styles.css 200 54386")
+    log.warning("GET /favicon.ico 404 242")
+    sleep(1)
+
+    log.debug(
+        "JSONRPC request\n--> %r\n<-- %r",
+        {
+            "version": "1.1",
+            "method": "confirmFruitPurchase",
+            "params": [["apple", "orange", "mangoes", "pomelo"], 1.123],
+            "id": "194521489",
+        },
+        {"version": "1.1", "result": True, "error": None, "id": "194521489"},
+    )
+    log.debug(
+        "Loading configuration file /adasd/asdasd/qeqwe/qwrqwrqwr/sdgsdgsdg/werwerwer/dfgerert/ertertert/ertetert/werwerwer"
+    )
+    log.error("Unable to find 'pomelo' in database!")
+    log.info("POST /jsonrpc/ 200 65532")
+    log.info("POST /admin/ 401 42234")
+    log.warning("password was rejected for admin site.")
+
+    def divide() -> None:
+        number = 1
+        divisor = 0
+        foos = ["foo"] * 100
+        log.debug("in divide")
+        try:
+            number / divisor
+        except:
+            log.exception("An error of some kind occurred!")
+
+    divide()
+    sleep(1)
+    log.critical("Out of memory!")
+    log.info("Server exited with code=-1")
+    log.info("[bold]EXITING...[/bold]", extra=dict(markup=True))

llava/lib/python3.10/site-packages/pip/_vendor/rich/markup.py

@@ -0,0 +1,251 @@
+import re
+from ast import literal_eval
+from operator import attrgetter
+from typing import Callable, Iterable, List, Match, NamedTuple, Optional, Tuple, Union
+
+from ._emoji_replace import _emoji_replace
+from .emoji import EmojiVariant
+from .errors import MarkupError
+from .style import Style
+from .text import Span, Text
+
+RE_TAGS = re.compile(
+    r"""((\\*)\[([a-z#/@][^[]*?)])""",
+    re.VERBOSE,
+)
+
+RE_HANDLER = re.compile(r"^([\w.]*?)(\(.*?\))?$")
+
+
+class Tag(NamedTuple):
+    """A tag in console markup."""
+
+    name: str
+    """The tag name. e.g. 'bold'."""
+    parameters: Optional[str]
+    """Any additional parameters after the name."""
+
+    def __str__(self) -> str:
+        return (
+            self.name if self.parameters is None else f"{self.name} {self.parameters}"
+        )
+
+    @property
+    def markup(self) -> str:
+        """Get the string representation of this tag."""
+        return (
+            f"[{self.name}]"
+            if self.parameters is None
+            else f"[{self.name}={self.parameters}]"
+        )
+
+
+_ReStringMatch = Match[str]  # regex match object
+_ReSubCallable = Callable[[_ReStringMatch], str]  # Callable invoked by re.sub
+_EscapeSubMethod = Callable[[_ReSubCallable, str], str]  # Sub method of a compiled re
+
+
+def escape(
+    markup: str,
+    _escape: _EscapeSubMethod = re.compile(r"(\\*)(\[[a-z#/@][^[]*?])").sub,
+) -> str:
+    """Escapes text so that it won't be interpreted as markup.
+
+    Args:
+        markup (str): Content to be inserted in to markup.
+
+    Returns:
+        str: Markup with square brackets escaped.
+    """
+
+    def escape_backslashes(match: Match[str]) -> str:
+        """Called by re.sub replace matches."""
+        backslashes, text = match.groups()
+        return f"{backslashes}{backslashes}\\{text}"
+
+    markup = _escape(escape_backslashes, markup)
+    if markup.endswith("\\") and not markup.endswith("\\\\"):
+        return markup + "\\"
+
+    return markup
+
+
+def _parse(markup: str) -> Iterable[Tuple[int, Optional[str], Optional[Tag]]]:
+    """Parse markup in to an iterable of tuples of (position, text, tag).
+
+    Args:
+        markup (str): A string containing console markup
+
+    """
+    position = 0
+    _divmod = divmod
+    _Tag = Tag
+    for match in RE_TAGS.finditer(markup):
+        full_text, escapes, tag_text = match.groups()
+        start, end = match.span()
+        if start > position:
+            yield start, markup[position:start], None
+        if escapes:
+            backslashes, escaped = _divmod(len(escapes), 2)
+            if backslashes:
+                # Literal backslashes
+                yield start, "\\" * backslashes, None
+                start += backslashes * 2
+            if escaped:
+                # Escape of tag
+                yield start, full_text[len(escapes) :], None
+                position = end
+                continue
+        text, equals, parameters = tag_text.partition("=")
+        yield start, None, _Tag(text, parameters if equals else None)
+        position = end
+    if position < len(markup):
+        yield position, markup[position:], None
+
+
+def render(
+    markup: str,
+    style: Union[str, Style] = "",
+    emoji: bool = True,
+    emoji_variant: Optional[EmojiVariant] = None,
+) -> Text:
+    """Render console markup in to a Text instance.
+
+    Args:
+        markup (str): A string containing console markup.
+        style: (Union[str, Style]): The style to use.
+        emoji (bool, optional): Also render emoji code. Defaults to True.
+        emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.
+
+
+    Raises:
+        MarkupError: If there is a syntax error in the markup.
+
+    Returns:
+        Text: A test instance.
+    """
+    emoji_replace = _emoji_replace
+    if "[" not in markup:
+        return Text(
+            emoji_replace(markup, default_variant=emoji_variant) if emoji else markup,
+            style=style,
+        )
+    text = Text(style=style)
+    append = text.append
+    normalize = Style.normalize
+
+    style_stack: List[Tuple[int, Tag]] = []
+    pop = style_stack.pop
+
+    spans: List[Span] = []
+    append_span = spans.append
+
+    _Span = Span
+    _Tag = Tag
+
+    def pop_style(style_name: str) -> Tuple[int, Tag]:
+        """Pop tag matching given style name."""
+        for index, (_, tag) in enumerate(reversed(style_stack), 1):
+            if tag.name == style_name:
+                return pop(-index)
+        raise KeyError(style_name)
+
+    for position, plain_text, tag in _parse(markup):
+        if plain_text is not None:
+            # Handle open brace escapes, where the brace is not part of a tag.
+            plain_text = plain_text.replace("\\[", "[")
+            append(emoji_replace(plain_text) if emoji else plain_text)
+        elif tag is not None:
+            if tag.name.startswith("/"):  # Closing tag
+                style_name = tag.name[1:].strip()
+
+                if style_name:  # explicit close
+                    style_name = normalize(style_name)
+                    try:
+                        start, open_tag = pop_style(style_name)
+                    except KeyError:
+                        raise MarkupError(
+                            f"closing tag '{tag.markup}' at position {position} doesn't match any open tag"
+                        ) from None
+                else:  # implicit close
+                    try:
+                        start, open_tag = pop()
+                    except IndexError:
+                        raise MarkupError(
+                            f"closing tag '[/]' at position {position} has nothing to close"
+                        ) from None
+
+                if open_tag.name.startswith("@"):
+                    if open_tag.parameters:
+                        handler_name = ""
+                        parameters = open_tag.parameters.strip()
+                        handler_match = RE_HANDLER.match(parameters)
+                        if handler_match is not None:
+                            handler_name, match_parameters = handler_match.groups()
+                            parameters = (
+                                "()" if match_parameters is None else match_parameters
+                            )
+
+                        try:
+                            meta_params = literal_eval(parameters)
+                        except SyntaxError as error:
+                            raise MarkupError(
+                                f"error parsing {parameters!r} in {open_tag.parameters!r}; {error.msg}"
+                            )
+                        except Exception as error:
+                            raise MarkupError(
+                                f"error parsing {open_tag.parameters!r}; {error}"
+                            ) from None
+
+                        if handler_name:
+                            meta_params = (
+                                handler_name,
+                                meta_params
+                                if isinstance(meta_params, tuple)
+                                else (meta_params,),
+                            )
+
+                    else:
+                        meta_params = ()
+
+                    append_span(
+                        _Span(
+                            start, len(text), Style(meta={open_tag.name: meta_params})
+                        )
+                    )
+                else:
+                    append_span(_Span(start, len(text), str(open_tag)))
+
+            else:  # Opening tag
+                normalized_tag = _Tag(normalize(tag.name), tag.parameters)
+                style_stack.append((len(text), normalized_tag))
+
+    text_length = len(text)
+    while style_stack:
+        start, tag = style_stack.pop()
+        style = str(tag)
+        if style:
+            append_span(_Span(start, text_length, style))
+
+    text.spans = sorted(spans[::-1], key=attrgetter("start"))
+    return text
+
+
+if __name__ == "__main__":  # pragma: no cover
+    MARKUP = [
+        "[red]Hello World[/red]",
+        "[magenta]Hello [b]World[/b]",
+        "[bold]Bold[italic] bold and italic [/bold]italic[/italic]",
+        "Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog",
+        ":warning-emoji: [bold red blink] DANGER![/]",
+    ]
+
+    from pip._vendor.rich import print
+    from pip._vendor.rich.table import Table
+
+    grid = Table("Markup", "Result", padding=(0, 1))
+
+    for markup in MARKUP:
+        grid.add_row(Text(markup), markup)
+
+    print(grid)

llava/lib/python3.10/site-packages/pip/_vendor/rich/progress.py

@@ -0,0 +1,1715 @@
+import io
+import sys
+import typing
+import warnings
+from abc import ABC, abstractmethod
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import timedelta
+from io import RawIOBase, UnsupportedOperation
+from math import ceil
+from mmap import mmap
+from operator import length_hint
+from os import PathLike, stat
+from threading import Event, RLock, Thread
+from types import TracebackType
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    ContextManager,
+    Deque,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    NamedTuple,
+    NewType,
+    Optional,
+    Sequence,
+    TextIO,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from pip._vendor.typing_extensions import Literal  # pragma: no cover
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from pip._vendor.typing_extensions import Self  # pragma: no cover
+
+from . import filesize, get_console
+from .console import Console, Group, JustifyMethod, RenderableType
+from .highlighter import Highlighter
+from .jupyter import JupyterMixin
+from .live import Live
+from .progress_bar import ProgressBar
+from .spinner import Spinner
+from .style import StyleType
+from .table import Column, Table
+from .text import Text, TextType
+
+TaskID = NewType("TaskID", int)
+
+ProgressType = TypeVar("ProgressType")
+
+GetTimeCallable = Callable[[], float]
+
+
+_I = typing.TypeVar("_I", TextIO, BinaryIO)
+
+
+class _TrackThread(Thread):
+    """A thread to periodically update progress."""
+
+    def __init__(self, progress: "Progress", task_id: "TaskID", update_period: float):
+        self.progress = progress
+        self.task_id = task_id
+        self.update_period = update_period
+        self.done = Event()
+
+        self.completed = 0
+        super().__init__(daemon=True)
+
+    def run(self) -> None:
+        task_id = self.task_id
+        advance = self.progress.advance
+        update_period = self.update_period
+        last_completed = 0
+        wait = self.done.wait
+        while not wait(update_period) and self.progress.live.is_started:
+            completed = self.completed
+            if last_completed != completed:
+                advance(task_id, completed - last_completed)
+                last_completed = completed
+
+        self.progress.update(self.task_id, completed=self.completed, refresh=True)
+
+    def __enter__(self) -> "_TrackThread":
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.done.set()
+        self.join()
+
+
+def track(
+    sequence: Union[Sequence[ProgressType], Iterable[ProgressType]],
+    description: str = "Working...",
+    total: Optional[float] = None,
+    completed: int = 0,
+    auto_refresh: bool = True,
+    console: Optional[Console] = None,
+    transient: bool = False,
+    get_time: Optional[Callable[[], float]] = None,
+    refresh_per_second: float = 10,
+    style: StyleType = "bar.back",
+    complete_style: StyleType = "bar.complete",
+    finished_style: StyleType = "bar.finished",
+    pulse_style: StyleType = "bar.pulse",
+    update_period: float = 0.1,
+    disable: bool = False,
+    show_speed: bool = True,
+) -> Iterable[ProgressType]:
+    """Track progress by iterating over a sequence.
+
+    Args:
+        sequence (Iterable[ProgressType]): A sequence (must support "len") you wish to iterate over.
+        description (str, optional): Description of task show next to progress bar. Defaults to "Working".
+        total: (float, optional): Total number of steps. Default is len(sequence).
+        completed (int, optional): Number of steps completed so far. Defaults to 0.
+        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
+        transient: (bool, optional): Clear the progress on exit. Defaults to False.
+        console (Console, optional): Console to write to. Default creates internal Console instance.
+        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
+        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.finished".
+        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
+        update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
+        disable (bool, optional): Disable display of progress.
+        show_speed (bool, optional): Show speed if total isn't known. Defaults to True.
+    Returns:
+        Iterable[ProgressType]: An iterable of the values in the sequence.
+
+    """
+
+    columns: List["ProgressColumn"] = (
+        [TextColumn("[progress.description]{task.description}")] if description else []
+    )
+    columns.extend(
+        (
+            BarColumn(
+                style=style,
+                complete_style=complete_style,
+                finished_style=finished_style,
+                pulse_style=pulse_style,
+            ),
+            TaskProgressColumn(show_speed=show_speed),
+            TimeRemainingColumn(elapsed_when_finished=True),
+        )
+    )
+    progress = Progress(
+        *columns,
+        auto_refresh=auto_refresh,
+        console=console,
+        transient=transient,
+        get_time=get_time,
+        refresh_per_second=refresh_per_second or 10,
+        disable=disable,
+    )
+
+    with progress:
+        yield from progress.track(
+            sequence,
+            total=total,
+            completed=completed,
+            description=description,
+            update_period=update_period,
+        )
+
+
+class _Reader(RawIOBase, BinaryIO):
+    """A reader that tracks progress while it's being read from."""
+
+    def __init__(
+        self,
+        handle: BinaryIO,
+        progress: "Progress",
+        task: TaskID,
+        close_handle: bool = True,
+    ) -> None:
+        self.handle = handle
+        self.progress = progress
+        self.task = task
+        self.close_handle = close_handle
+        self._closed = False
+
+    def __enter__(self) -> "_Reader":
+        self.handle.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+    def __iter__(self) -> BinaryIO:
+        return self
+
+    def __next__(self) -> bytes:
+        line = next(self.handle)
+        self.progress.advance(self.task, advance=len(line))
+        return line
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def fileno(self) -> int:
+        return self.handle.fileno()
+
+    def isatty(self) -> bool:
+        return self.handle.isatty()
+
+    @property
+    def mode(self) -> str:
+        return self.handle.mode
+
+    @property
+    def name(self) -> str:
+        return self.handle.name
+
+    def readable(self) -> bool:
+        return self.handle.readable()
+
+    def seekable(self) -> bool:
+        return self.handle.seekable()
+
+    def writable(self) -> bool:
+        return False
+
+    def read(self, size: int = -1) -> bytes:
+        block = self.handle.read(size)
+        self.progress.advance(self.task, advance=len(block))
+        return block
+
+    def readinto(self, b: Union[bytearray, memoryview, mmap]):  # type: ignore[no-untyped-def, override]
+        n = self.handle.readinto(b)  # type: ignore[attr-defined]
+        self.progress.advance(self.task, advance=n)
+        return n
+
+    def readline(self, size: int = -1) -> bytes:  # type: ignore[override]
+        line = self.handle.readline(size)
+        self.progress.advance(self.task, advance=len(line))
+        return line
+
+    def readlines(self, hint: int = -1) -> List[bytes]:
+        lines = self.handle.readlines(hint)
+        self.progress.advance(self.task, advance=sum(map(len, lines)))
+        return lines
+
+    def close(self) -> None:
+        if self.close_handle:
+            self.handle.close()
+        self._closed = True
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        pos = self.handle.seek(offset, whence)
+        self.progress.update(self.task, completed=pos)
+        return pos
+
+    def tell(self) -> int:
+        return self.handle.tell()
+
+    def write(self, s: Any) -> int:
+        raise UnsupportedOperation("write")
+
+    def writelines(self, lines: Iterable[Any]) -> None:
+        raise UnsupportedOperation("writelines")
+
+
+class _ReadContext(ContextManager[_I], Generic[_I]):
+    """A utility class to handle a context for both a reader and a progress."""
+
+    def __init__(self, progress: "Progress", reader: _I) -> None:
+        self.progress = progress
+        self.reader: _I = reader
+
+    def __enter__(self) -> _I:
+        self.progress.start()
+        return self.reader.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.progress.stop()
+        self.reader.__exit__(exc_type, exc_val, exc_tb)
+
+
+def wrap_file(
+    file: BinaryIO,
+    total: int,
+    *,
+    description: str = "Reading...",
+    auto_refresh: bool = True,
+    console: Optional[Console] = None,
+    transient: bool = False,
+    get_time: Optional[Callable[[], float]] = None,
+    refresh_per_second: float = 10,
+    style: StyleType = "bar.back",
+    complete_style: StyleType = "bar.complete",
+    finished_style: StyleType = "bar.finished",
+    pulse_style: StyleType = "bar.pulse",
+    disable: bool = False,
+) -> ContextManager[BinaryIO]:
+    """Read bytes from a file while tracking progress.
+
+    Args:
+        file (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
+        total (int): Total number of bytes to read.
+        description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
+        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
+        transient: (bool, optional): Clear the progress on exit. Defaults to False.
+        console (Console, optional): Console to write to. Default creates internal Console instance.
+        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
+        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.finished".
+        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
+        disable (bool, optional): Disable display of progress.
+    Returns:
+        ContextManager[BinaryIO]: A context manager yielding a progress reader.
+
+    """
+
+    columns: List["ProgressColumn"] = (
+        [TextColumn("[progress.description]{task.description}")] if description else []
+    )
+    columns.extend(
+        (
+            BarColumn(
+                style=style,
+                complete_style=complete_style,
+                finished_style=finished_style,
+                pulse_style=pulse_style,
+            ),
+            DownloadColumn(),
+            TimeRemainingColumn(),
+        )
+    )
+    progress = Progress(
+        *columns,
+        auto_refresh=auto_refresh,
+        console=console,
+        transient=transient,
+        get_time=get_time,
+        refresh_per_second=refresh_per_second or 10,
+        disable=disable,
+    )
+
+    reader = progress.wrap_file(file, total=total, description=description)
+    return _ReadContext(progress, reader)
+
+
+@typing.overload
+def open(
+    file: Union[str, "PathLike[str]", bytes],
+    mode: Union[Literal["rt"], Literal["r"]],
+    buffering: int = -1,
+    encoding: Optional[str] = None,
+    errors: Optional[str] = None,
+    newline: Optional[str] = None,
+    *,
+    total: Optional[int] = None,
+    description: str = "Reading...",
+    auto_refresh: bool = True,
+    console: Optional[Console] = None,
+    transient: bool = False,
+    get_time: Optional[Callable[[], float]] = None,
+    refresh_per_second: float = 10,
+    style: StyleType = "bar.back",
+    complete_style: StyleType = "bar.complete",
+    finished_style: StyleType = "bar.finished",
+    pulse_style: StyleType = "bar.pulse",
+    disable: bool = False,
+) -> ContextManager[TextIO]:
+    pass
+
+
+@typing.overload
+def open(
+    file: Union[str, "PathLike[str]", bytes],
+    mode: Literal["rb"],
+    buffering: int = -1,
+    encoding: Optional[str] = None,
+    errors: Optional[str] = None,
+    newline: Optional[str] = None,
+    *,
+    total: Optional[int] = None,
+    description: str = "Reading...",
+    auto_refresh: bool = True,
+    console: Optional[Console] = None,
+    transient: bool = False,
+    get_time: Optional[Callable[[], float]] = None,
+    refresh_per_second: float = 10,
+    style: StyleType = "bar.back",
+    complete_style: StyleType = "bar.complete",
+    finished_style: StyleType = "bar.finished",
+    pulse_style: StyleType = "bar.pulse",
+    disable: bool = False,
+) -> ContextManager[BinaryIO]:
+    pass
+
+
+def open(
+    file: Union[str, "PathLike[str]", bytes],
+    mode: Union[Literal["rb"], Literal["rt"], Literal["r"]] = "r",
+    buffering: int = -1,
+    encoding: Optional[str] = None,
+    errors: Optional[str] = None,
+    newline: Optional[str] = None,
+    *,
+    total: Optional[int] = None,
+    description: str = "Reading...",
+    auto_refresh: bool = True,
+    console: Optional[Console] = None,
+    transient: bool = False,
+    get_time: Optional[Callable[[], float]] = None,
+    refresh_per_second: float = 10,
+    style: StyleType = "bar.back",
+    complete_style: StyleType = "bar.complete",
+    finished_style: StyleType = "bar.finished",
+    pulse_style: StyleType = "bar.pulse",
+    disable: bool = False,
+) -> Union[ContextManager[BinaryIO], ContextManager[TextIO]]:
+    """Read bytes from a file while tracking progress.
+
+    Args:
+        path (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
+        mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
+        buffering (int): The buffering strategy to use, see :func:`io.open`.
+        encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
+        errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
+        newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`
+        total: (int, optional): Total number of bytes to read. Must be provided if reading from a file handle. Default for a path is os.stat(file).st_size.
+        description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
+        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
+        transient: (bool, optional): Clear the progress on exit. Defaults to False.
+        console (Console, optional): Console to write to. Default creates internal Console instance.
+        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
+        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.finished".
+        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
+        disable (bool, optional): Disable display of progress.
+        encoding (str, optional): The encoding to use when reading in text mode.
+
+    Returns:
+        ContextManager[BinaryIO]: A context manager yielding a progress reader.
+
+    """
+
+    columns: List["ProgressColumn"] = (
+        [TextColumn("[progress.description]{task.description}")] if description else []
+    )
+    columns.extend(
+        (
+            BarColumn(
+                style=style,
+                complete_style=complete_style,
+                finished_style=finished_style,
+                pulse_style=pulse_style,
+            ),
+            DownloadColumn(),
+            TimeRemainingColumn(),
+        )
+    )
+    progress = Progress(
+        *columns,
+        auto_refresh=auto_refresh,
+        console=console,
+        transient=transient,
+        get_time=get_time,
+        refresh_per_second=refresh_per_second or 10,
+        disable=disable,
+    )
+
+    reader = progress.open(
+        file,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        errors=errors,
+        newline=newline,
+        total=total,
+        description=description,
+    )
+    return _ReadContext(progress, reader)  # type: ignore[return-value, type-var]
+
+
+class ProgressColumn(ABC):
+    """Base class for a widget to use in progress display."""
+
+    max_refresh: Optional[float] = None
+
+    def __init__(self, table_column: Optional[Column] = None) -> None:
+        self._table_column = table_column
+        self._renderable_cache: Dict[TaskID, Tuple[float, RenderableType]] = {}
+        self._update_time: Optional[float] = None
+
+    def get_table_column(self) -> Column:
+        """Get a table column, used to build tasks table."""
+        return self._table_column or Column()
+
+    def __call__(self, task: "Task") -> RenderableType:
+        """Called by the Progress object to return a renderable for the given task.
+
+        Args:
+            task (Task): An object containing information regarding the task.
+
+        Returns:
+            RenderableType: Anything renderable (including str).
+        """
+        current_time = task.get_time()
+        if self.max_refresh is not None and not task.completed:
+            try:
+                timestamp, renderable = self._renderable_cache[task.id]
+            except KeyError:
+                pass
+            else:
+                if timestamp + self.max_refresh > current_time:
+                    return renderable
+
+        renderable = self.render(task)
+        self._renderable_cache[task.id] = (current_time, renderable)
+        return renderable
+
+    @abstractmethod
+    def render(self, task: "Task") -> RenderableType:
+        """Should return a renderable object."""
+
+
+class RenderableColumn(ProgressColumn):
+    """A column to insert an arbitrary column.
+
+    Args:
+        renderable (RenderableType, optional): Any renderable. Defaults to empty string.
+    """
+
+    def __init__(
+        self, renderable: RenderableType = "", *, table_column: Optional[Column] = None
+    ):
+        self.renderable = renderable
+        super().__init__(table_column=table_column)
+
+    def render(self, task: "Task") -> RenderableType:
+        return self.renderable
+
+
+class SpinnerColumn(ProgressColumn):
+    """A column with a 'spinner' animation.
+
+    Args:
+        spinner_name (str, optional): Name of spinner animation. Defaults to "dots".
+        style (StyleType, optional): Style of spinner. Defaults to "progress.spinner".
+        speed (float, optional): Speed factor of spinner. Defaults to 1.0.
+        finished_text (TextType, optional): Text used when task is finished. Defaults to " ".
+    """
+
+    def __init__(
+        self,
+        spinner_name: str = "dots",
+        style: Optional[StyleType] = "progress.spinner",
+        speed: float = 1.0,
+        finished_text: TextType = " ",
+        table_column: Optional[Column] = None,
+    ):
+        self.spinner = Spinner(spinner_name, style=style, speed=speed)
+        self.finished_text = (
+            Text.from_markup(finished_text)
+            if isinstance(finished_text, str)
+            else finished_text
+        )
+        super().__init__(table_column=table_column)
+
+    def set_spinner(
+        self,
+        spinner_name: str,
+        spinner_style: Optional[StyleType] = "progress.spinner",
+        speed: float = 1.0,
+    ) -> None:
+        """Set a new spinner.
+
+        Args:
+            spinner_name (str): Spinner name, see python -m rich.spinner.
+            spinner_style (Optional[StyleType], optional): Spinner style. Defaults to "progress.spinner".
+            speed (float, optional): Speed factor of spinner. Defaults to 1.0.
+        """
+        self.spinner = Spinner(spinner_name, style=spinner_style, speed=speed)
+
+    def render(self, task: "Task") -> RenderableType:
+        text = (
+            self.finished_text
+            if task.finished
+            else self.spinner.render(task.get_time())
+        )
+        return text
+
+
+class TextColumn(ProgressColumn):
+    """A column containing text."""
+
+    def __init__(
+        self,
+        text_format: str,
+        style: StyleType = "none",
+        justify: JustifyMethod = "left",
+        markup: bool = True,
+        highlighter: Optional[Highlighter] = None,
+        table_column: Optional[Column] = None,
+    ) -> None:
+        self.text_format = text_format
+        self.justify: JustifyMethod = justify
+        self.style = style
+        self.markup = markup
+        self.highlighter = highlighter
+        super().__init__(table_column=table_column or Column(no_wrap=True))
+
+    def render(self, task: "Task") -> Text:
+        _text = self.text_format.format(task=task)
+        if self.markup:
+            text = Text.from_markup(_text, style=self.style, justify=self.justify)
+        else:
+            text = Text(_text, style=self.style, justify=self.justify)
+        if self.highlighter:
+            self.highlighter.highlight(text)
+        return text
+
+
+class BarColumn(ProgressColumn):
+    """Renders a visual progress bar.
+
+    Args:
+        bar_width (Optional[int], optional): Width of bar or None for full width. Defaults to 40.
+        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.finished".
+        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
+    """
+
+    def __init__(
+        self,
+        bar_width: Optional[int] = 40,
+        style: StyleType = "bar.back",
+        complete_style: StyleType = "bar.complete",
+        finished_style: StyleType = "bar.finished",
+        pulse_style: StyleType = "bar.pulse",
+        table_column: Optional[Column] = None,
+    ) -> None:
+        self.bar_width = bar_width
+        self.style = style
+        self.complete_style = complete_style
+        self.finished_style = finished_style
+        self.pulse_style = pulse_style
+        super().__init__(table_column=table_column)
+
+    def render(self, task: "Task") -> ProgressBar:
+        """Gets a progress bar widget for a task."""
+        return ProgressBar(
+            total=max(0, task.total) if task.total is not None else None,
+            completed=max(0, task.completed),
+            width=None if self.bar_width is None else max(1, self.bar_width),
+            pulse=not task.started,
+            animation_time=task.get_time(),
+            style=self.style,
+            complete_style=self.complete_style,
+            finished_style=self.finished_style,
+            pulse_style=self.pulse_style,
+        )
+
+
+class TimeElapsedColumn(ProgressColumn):
+    """Renders time elapsed."""
+
+    def render(self, task: "Task") -> Text:
+        """Show time elapsed."""
+        elapsed = task.finished_time if task.finished else task.elapsed
+        if elapsed is None:
+            return Text("-:--:--", style="progress.elapsed")
+        delta = timedelta(seconds=max(0, int(elapsed)))
+        return Text(str(delta), style="progress.elapsed")
+
+
+class TaskProgressColumn(TextColumn):
+    """Show task progress as a percentage.
+
+    Args:
+        text_format (str, optional): Format for percentage display. Defaults to "[progress.percentage]{task.percentage:>3.0f}%".
+        text_format_no_percentage (str, optional): Format if percentage is unknown. Defaults to "".
+        style (StyleType, optional): Style of output. Defaults to "none".
+        justify (JustifyMethod, optional): Text justification. Defaults to "left".
+        markup (bool, optional): Enable markup. Defaults to True.
+        highlighter (Optional[Highlighter], optional): Highlighter to apply to output. Defaults to None.
+        table_column (Optional[Column], optional): Table Column to use. Defaults to None.
+        show_speed (bool, optional): Show speed if total is unknown. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        text_format: str = "[progress.percentage]{task.percentage:>3.0f}%",
+        text_format_no_percentage: str = "",
+        style: StyleType = "none",
+        justify: JustifyMethod = "left",
+        markup: bool = True,
+        highlighter: Optional[Highlighter] = None,
+        table_column: Optional[Column] = None,
+        show_speed: bool = False,
+    ) -> None:
+        self.text_format_no_percentage = text_format_no_percentage
+        self.show_speed = show_speed
+        super().__init__(
+            text_format=text_format,
+            style=style,
+            justify=justify,
+            markup=markup,
+            highlighter=highlighter,
+            table_column=table_column,
+        )
+
+    @classmethod
+    def render_speed(cls, speed: Optional[float]) -> Text:
+        """Render the speed in iterations per second.
+
+        Args:
+            task (Task): A Task object.
+
+        Returns:
+            Text: Text object containing the task speed.
+        """
+        if speed is None:
+            return Text("", style="progress.percentage")
+        unit, suffix = filesize.pick_unit_and_suffix(
+            int(speed),
+            ["", "×10³", "×10⁶", "×10⁹", "×10¹²"],
+            1000,
+        )
+        data_speed = speed / unit
+        return Text(f"{data_speed:.1f}{suffix} it/s", style="progress.percentage")
+
+    def render(self, task: "Task") -> Text:
+        if task.total is None and self.show_speed:
+            return self.render_speed(task.finished_speed or task.speed)
+        text_format = (
+            self.text_format_no_percentage if task.total is None else self.text_format
+        )
+        _text = text_format.format(task=task)
+        if self.markup:
+            text = Text.from_markup(_text, style=self.style, justify=self.justify)
+        else:
+            text = Text(_text, style=self.style, justify=self.justify)
+        if self.highlighter:
+            self.highlighter.highlight(text)
+        return text
+
+
+class TimeRemainingColumn(ProgressColumn):
+    """Renders estimated time remaining.
+
+    Args:
+        compact (bool, optional): Render MM:SS when time remaining is less than an hour. Defaults to False.
+        elapsed_when_finished (bool, optional): Render time elapsed when the task is finished. Defaults to False.
+    """
+
+    # Only refresh twice a second to prevent jitter
+    max_refresh = 0.5
+
+    def __init__(
+        self,
+        compact: bool = False,
+        elapsed_when_finished: bool = False,
+        table_column: Optional[Column] = None,
+    ):
+        self.compact = compact
+        self.elapsed_when_finished = elapsed_when_finished
+        super().__init__(table_column=table_column)
+
+    def render(self, task: "Task") -> Text:
+        """Show time remaining."""
+        if self.elapsed_when_finished and task.finished:
+            task_time = task.finished_time
+            style = "progress.elapsed"
+        else:
+            task_time = task.time_remaining
+            style = "progress.remaining"
+
+        if task.total is None:
+            return Text("", style=style)
+
+        if task_time is None:
+            return Text("--:--" if self.compact else "-:--:--", style=style)
+
+        # Based on https://github.com/tqdm/tqdm/blob/master/tqdm/std.py
+        minutes, seconds = divmod(int(task_time), 60)
+        hours, minutes = divmod(minutes, 60)
+
+        if self.compact and not hours:
+            formatted = f"{minutes:02d}:{seconds:02d}"
+        else:
+            formatted = f"{hours:d}:{minutes:02d}:{seconds:02d}"
+
+        return Text(formatted, style=style)
+
+
+class FileSizeColumn(ProgressColumn):
+    """Renders completed filesize."""
+
+    def render(self, task: "Task") -> Text:
+        """Show data completed."""
+        data_size = filesize.decimal(int(task.completed))
+        return Text(data_size, style="progress.filesize")
+
+
+class TotalFileSizeColumn(ProgressColumn):
+    """Renders total filesize."""
+
+    def render(self, task: "Task") -> Text:
+        """Show data completed."""
+        data_size = filesize.decimal(int(task.total)) if task.total is not None else ""
+        return Text(data_size, style="progress.filesize.total")
+
+
+class MofNCompleteColumn(ProgressColumn):
+    """Renders completed count/total, e.g. '  10/1000'.
+
+    Best for bounded tasks with int quantities.
+
+    Space pads the completed count so that progress length does not change as task progresses
+    past powers of 10.
+
+    Args:
+        separator (str, optional): Text to separate completed and total values. Defaults to "/".
+    """
+
+    def __init__(self, separator: str = "/", table_column: Optional[Column] = None):
+        self.separator = separator
+        super().__init__(table_column=table_column)
+
+    def render(self, task: "Task") -> Text:
+        """Show completed/total."""
+        completed = int(task.completed)
+        total = int(task.total) if task.total is not None else "?"
+        total_width = len(str(total))
+        return Text(
+            f"{completed:{total_width}d}{self.separator}{total}",
+            style="progress.download",
+        )
+
+
+class DownloadColumn(ProgressColumn):
+    """Renders file size downloaded and total, e.g. '0.5/2.3 GB'.
+
+    Args:
+        binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.
+    """
+
+    def __init__(
+        self, binary_units: bool = False, table_column: Optional[Column] = None
+    ) -> None:
+        self.binary_units = binary_units
+        super().__init__(table_column=table_column)
+
+    def render(self, task: "Task") -> Text:
+        """Calculate common unit for completed and total."""
+        completed = int(task.completed)
+
+        unit_and_suffix_calculation_base = (
+            int(task.total) if task.total is not None else completed
+        )
+        if self.binary_units:
+            unit, suffix = filesize.pick_unit_and_suffix(
+                unit_and_suffix_calculation_base,
+                ["bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"],
+                1024,
+            )
+        else:
+            unit, suffix = filesize.pick_unit_and_suffix(
+                unit_and_suffix_calculation_base,
+                ["bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"],
+                1000,
+            )
+        precision = 0 if unit == 1 else 1
+
+        completed_ratio = completed / unit
+        completed_str = f"{completed_ratio:,.{precision}f}"
+
+        if task.total is not None:
+            total = int(task.total)
+            total_ratio = total / unit
+            total_str = f"{total_ratio:,.{precision}f}"
+        else:
+            total_str = "?"
+
+        download_status = f"{completed_str}/{total_str} {suffix}"
+        download_text = Text(download_status, style="progress.download")
+        return download_text
+
+
+class TransferSpeedColumn(ProgressColumn):
+    """Renders human readable transfer speed."""
+
+    def render(self, task: "Task") -> Text:
+        """Show data transfer speed."""
+        speed = task.finished_speed or task.speed
+        if speed is None:
+            return Text("?", style="progress.data.speed")
+        data_speed = filesize.decimal(int(speed))
+        return Text(f"{data_speed}/s", style="progress.data.speed")
+
+
+class ProgressSample(NamedTuple):
+    """Sample of progress for a given time."""
+
+    timestamp: float
+    """Timestamp of sample."""
+    completed: float
+    """Number of steps completed."""
+
+
+@dataclass
+class Task:
+    """Information regarding a progress task.
+
+    This object should be considered read-only outside of the :class:`~Progress` class.
+
+    """
+
+    id: TaskID
+    """Task ID associated with this task (used in Progress methods)."""
+
+    description: str
+    """str: Description of the task."""
+
+    total: Optional[float]
+    """Optional[float]: Total number of steps in this task."""
+
+    completed: float
+    """float: Number of steps completed"""
+
+    _get_time: GetTimeCallable
+    """Callable to get the current time."""
+
+    finished_time: Optional[float] = None
+    """float: Time task was finished."""
+
+    visible: bool = True
+    """bool: Indicates if this task is visible in the progress display."""
+
+    fields: Dict[str, Any] = field(default_factory=dict)
+    """dict: Arbitrary fields passed in via Progress.update."""
+
+    start_time: Optional[float] = field(default=None, init=False, repr=False)
+    """Optional[float]: Time this task was started, or None if not started."""
+
+    stop_time: Optional[float] = field(default=None, init=False, repr=False)
+    """Optional[float]: Time this task was stopped, or None if not stopped."""
+
+    finished_speed: Optional[float] = None
+    """Optional[float]: The last speed for a finished task."""
+
+    _progress: Deque[ProgressSample] = field(
+        default_factory=lambda: deque(maxlen=1000), init=False, repr=False
+    )
+
+    _lock: RLock = field(repr=False, default_factory=RLock)
+    """Thread lock."""
+
+    def get_time(self) -> float:
+        """float: Get the current time, in seconds."""
+        return self._get_time()
+
+    @property
+    def started(self) -> bool:
+        """bool: Check if the task as started."""
+        return self.start_time is not None
+
+    @property
+    def remaining(self) -> Optional[float]:
+        """Optional[float]: Get the number of steps remaining, if a non-None total was set."""
+        if self.total is None:
+            return None
+        return self.total - self.completed
+
+    @property
+    def elapsed(self) -> Optional[float]:
+        """Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started."""
+        if self.start_time is None:
+            return None
+        if self.stop_time is not None:
+            return self.stop_time - self.start_time
+        return self.get_time() - self.start_time
+
+    @property
+    def finished(self) -> bool:
+        """Check if the task has finished."""
+        return self.finished_time is not None
+
+    @property
+    def percentage(self) -> float:
+        """float: Get progress of task as a percentage. If a None total was set, returns 0"""
+        if not self.total:
+            return 0.0
+        completed = (self.completed / self.total) * 100.0
+        completed = min(100.0, max(0.0, completed))
+        return completed
+
+    @property
+    def speed(self) -> Optional[float]:
+        """Optional[float]: Get the estimated speed in steps per second."""
+        if self.start_time is None:
+            return None
+        with self._lock:
+            progress = self._progress
+            if not progress:
+                return None
+            total_time = progress[-1].timestamp - progress[0].timestamp
+            if total_time == 0:
+                return None
+            iter_progress = iter(progress)
+            next(iter_progress)
+            total_completed = sum(sample.completed for sample in iter_progress)
+            speed = total_completed / total_time
+            return speed
+
+    @property
+    def time_remaining(self) -> Optional[float]:
+        """Optional[float]: Get estimated time to completion, or ``None`` if no data."""
+        if self.finished:
+            return 0.0
+        speed = self.speed
+        if not speed:
+            return None
+        remaining = self.remaining
+        if remaining is None:
+            return None
+        estimate = ceil(remaining / speed)
+        return estimate
+
+    def _reset(self) -> None:
+        """Reset progress."""
+        self._progress.clear()
+        self.finished_time = None
+        self.finished_speed = None
+
+
+class Progress(JupyterMixin):
+    """Renders an auto-updating progress bar(s).
+
+    Args:
+        console (Console, optional): Optional Console instance. Defaults to an internal Console instance writing to stdout.
+        auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`.
+        refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None.
+        speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30.
+        transient: (bool, optional): Clear the progress on exit. Defaults to False.
+        redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.
+        redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True.
+        get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None.
+        disable (bool, optional): Disable progress display. Defaults to False
+        expand (bool, optional): Expand tasks table to fit width. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        *columns: Union[str, ProgressColumn],
+        console: Optional[Console] = None,
+        auto_refresh: bool = True,
+        refresh_per_second: float = 10,
+        speed_estimate_period: float = 30.0,
+        transient: bool = False,
+        redirect_stdout: bool = True,
+        redirect_stderr: bool = True,
+        get_time: Optional[GetTimeCallable] = None,
+        disable: bool = False,
+        expand: bool = False,
+    ) -> None:
+        assert refresh_per_second > 0, "refresh_per_second must be > 0"
+        self._lock = RLock()
+        self.columns = columns or self.get_default_columns()
+        self.speed_estimate_period = speed_estimate_period
+
+        self.disable = disable
+        self.expand = expand
+        self._tasks: Dict[TaskID, Task] = {}
+        self._task_index: TaskID = TaskID(0)
+        self.live = Live(
+            console=console or get_console(),
+            auto_refresh=auto_refresh,
+            refresh_per_second=refresh_per_second,
+            transient=transient,
+            redirect_stdout=redirect_stdout,
+            redirect_stderr=redirect_stderr,
+            get_renderable=self.get_renderable,
+        )
+        self.get_time = get_time or self.console.get_time
+        self.print = self.console.print
+        self.log = self.console.log
+
+    @classmethod
+    def get_default_columns(cls) -> Tuple[ProgressColumn, ...]:
+        """Get the default columns used for a new Progress instance:
+           - a text column for the description (TextColumn)
+           - the bar itself (BarColumn)
+           - a text column showing completion percentage (TextColumn)
+           - an estimated-time-remaining column (TimeRemainingColumn)
+        If the Progress instance is created without passing a columns argument,
+        the default columns defined here will be used.
+
+        You can also create a Progress instance using custom columns before
+        and/or after the defaults, as in this example:
+
+            progress = Progress(
+                SpinnerColumn(),
+                *Progress.get_default_columns(),
+                "Elapsed:",
+                TimeElapsedColumn(),
+            )
+
+        This code shows the creation of a Progress display, containing
+        a spinner to the left, the default columns, and a labeled elapsed
+        time column.
+        """
+        return (
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeRemainingColumn(),
+        )
+
+    @property
+    def console(self) -> Console:
+        return self.live.console
+
+    @property
+    def tasks(self) -> List[Task]:
+        """Get a list of Task instances."""
+        with self._lock:
+            return list(self._tasks.values())
+
+    @property
+    def task_ids(self) -> List[TaskID]:
+        """A list of task IDs."""
+        with self._lock:
+            return list(self._tasks.keys())
+
+    @property
+    def finished(self) -> bool:
+        """Check if all tasks have been completed."""
+        with self._lock:
+            if not self._tasks:
+                return True
+            return all(task.finished for task in self._tasks.values())
+
+    def start(self) -> None:
+        """Start the progress display."""
+        if not self.disable:
+            self.live.start(refresh=True)
+
+    def stop(self) -> None:
+        """Stop the progress display."""
+        self.live.stop()
+        if not self.console.is_interactive and not self.console.is_jupyter:
+            self.console.print()
+
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.stop()
+
+    def track(
+        self,
+        sequence: Union[Iterable[ProgressType], Sequence[ProgressType]],
+        total: Optional[float] = None,
+        completed: int = 0,
+        task_id: Optional[TaskID] = None,
+        description: str = "Working...",
+        update_period: float = 0.1,
+    ) -> Iterable[ProgressType]:
+        """Track progress by iterating over a sequence.
+
+        Args:
+            sequence (Sequence[ProgressType]): A sequence of values you want to iterate over and track progress.
+            total: (float, optional): Total number of steps. Default is len(sequence).
+            completed (int, optional): Number of steps completed so far. Defaults to 0.
+            task_id: (TaskID): Task to track. Default is new task.
+            description: (str, optional): Description of task, if new task is created.
+            update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
+
+        Returns:
+            Iterable[ProgressType]: An iterable of values taken from the provided sequence.
+        """
+        if total is None:
+            total = float(length_hint(sequence)) or None
+
+        if task_id is None:
+            task_id = self.add_task(description, total=total, completed=completed)
+        else:
+            self.update(task_id, total=total, completed=completed)
+
+        if self.live.auto_refresh:
+            with _TrackThread(self, task_id, update_period) as track_thread:
+                for value in sequence:
+                    yield value
+                    track_thread.completed += 1
+        else:
+            advance = self.advance
+            refresh = self.refresh
+            for value in sequence:
+                yield value
+                advance(task_id, 1)
+                refresh()
+
+    def wrap_file(
+        self,
+        file: BinaryIO,
+        total: Optional[int] = None,
+        *,
+        task_id: Optional[TaskID] = None,
+        description: str = "Reading...",
+    ) -> BinaryIO:
+        """Track progress file reading from a binary file.
+
+        Args:
+            file (BinaryIO): A file-like object opened in binary mode.
+            total (int, optional): Total number of bytes to read. This must be provided unless a task with a total is also given.
+            task_id (TaskID): Task to track. Default is new task.
+            description (str, optional): Description of task, if new task is created.
+
+        Returns:
+            BinaryIO: A readable file-like object in binary mode.
+
+        Raises:
+            ValueError: When no total value can be extracted from the arguments or the task.
+        """
+        # attempt to recover the total from the task
+        total_bytes: Optional[float] = None
+        if total is not None:
+            total_bytes = total
+        elif task_id is not None:
+            with self._lock:
+                total_bytes = self._tasks[task_id].total
+        if total_bytes is None:
+            raise ValueError(
+                f"unable to get the total number of bytes, please specify 'total'"
+            )
+
+        # update total of task or create new task
+        if task_id is None:
+            task_id = self.add_task(description, total=total_bytes)
+        else:
+            self.update(task_id, total=total_bytes)
+
+        return _Reader(file, self, task_id, close_handle=False)
+
+    @typing.overload
+    def open(
+        self,
+        file: Union[str, "PathLike[str]", bytes],
+        mode: Literal["rb"],
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+        *,
+        total: Optional[int] = None,
+        task_id: Optional[TaskID] = None,
+        description: str = "Reading...",
+    ) -> BinaryIO:
+        pass
+
+    @typing.overload
+    def open(
+        self,
+        file: Union[str, "PathLike[str]", bytes],
+        mode: Union[Literal["r"], Literal["rt"]],
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+        *,
+        total: Optional[int] = None,
+        task_id: Optional[TaskID] = None,
+        description: str = "Reading...",
+    ) -> TextIO:
+        pass
+
+    def open(
+        self,
+        file: Union[str, "PathLike[str]", bytes],
+        mode: Union[Literal["rb"], Literal["rt"], Literal["r"]] = "r",
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+        *,
+        total: Optional[int] = None,
+        task_id: Optional[TaskID] = None,
+        description: str = "Reading...",
+    ) -> Union[BinaryIO, TextIO]:
+        """Track progress while reading from a binary file.
+
+        Args:
+            path (Union[str, PathLike[str]]): The path to the file to read.
+            mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
+            buffering (int): The buffering strategy to use, see :func:`io.open`.
+            encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
+            errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
+            newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`.
+            total (int, optional): Total number of bytes to read. If none given, os.stat(path).st_size is used.
+            task_id (TaskID): Task to track. Default is new task.
+            description (str, optional): Description of task, if new task is created.
+
+        Returns:
+            BinaryIO: A readable file-like object in binary mode.
+
+        Raises:
+            ValueError: When an invalid mode is given.
+        """
+        # normalize the mode (always rb, rt)
+        _mode = "".join(sorted(mode, reverse=False))
+        if _mode not in ("br", "rt", "r"):
+            raise ValueError(f"invalid mode {mode!r}")
+
+        # patch buffering to provide the same behaviour as the builtin `open`
+        line_buffering = buffering == 1
+        if _mode == "br" and buffering == 1:
+            warnings.warn(
+                "line buffering (buffering=1) isn't supported in binary mode, the default buffer size will be used",
+                RuntimeWarning,
+            )
+            buffering = -1
+        elif _mode in ("rt", "r"):
+            if buffering == 0:
+                raise ValueError("can't have unbuffered text I/O")
+            elif buffering == 1:
+                buffering = -1
+
+        # attempt to get the total with `os.stat`
+        if total is None:
+            total = stat(file).st_size
+
+        # update total of task or create new task
+        if task_id is None:
+            task_id = self.add_task(description, total=total)
+        else:
+            self.update(task_id, total=total)
+
+        # open the file in binary mode,
+        handle = io.open(file, "rb", buffering=buffering)
+        reader = _Reader(handle, self, task_id, close_handle=True)
+
+        # wrap the reader in a `TextIOWrapper` if text mode
+        if mode in ("r", "rt"):
+            return io.TextIOWrapper(
+                reader,
+                encoding=encoding,
+                errors=errors,
+                newline=newline,
+                line_buffering=line_buffering,
+            )
+
+        return reader
+
+    def start_task(self, task_id: TaskID) -> None:
+        """Start a task.
+
+        Starts a task (used when calculating elapsed time). You may need to call this manually,
+        if you called ``add_task`` with ``start=False``.
+
+        Args:
+            task_id (TaskID): ID of task.
+        """
+        with self._lock:
+            task = self._tasks[task_id]
+            if task.start_time is None:
+                task.start_time = self.get_time()
+
+    def stop_task(self, task_id: TaskID) -> None:
+        """Stop a task.
+
+        This will freeze the elapsed time on the task.
+
+        Args:
+            task_id (TaskID): ID of task.
+        """
+        with self._lock:
+            task = self._tasks[task_id]
+            current_time = self.get_time()
+            if task.start_time is None:
+                task.start_time = current_time
+            task.stop_time = current_time
+
+    def update(
+        self,
+        task_id: TaskID,
+        *,
+        total: Optional[float] = None,
+        completed: Optional[float] = None,
+        advance: Optional[float] = None,
+        description: Optional[str] = None,
+        visible: Optional[bool] = None,
+        refresh: bool = False,
+        **fields: Any,
+    ) -> None:
+        """Update information associated with a task.
+
+        Args:
+            task_id (TaskID): Task id (returned by add_task).
+            total (float, optional): Updates task.total if not None.
+            completed (float, optional): Updates task.completed if not None.
+            advance (float, optional): Add a value to task.completed if not None.
+            description (str, optional): Change task description if not None.
+            visible (bool, optional): Set visible flag if not None.
+            refresh (bool): Force a refresh of progress information. Default is False.
+            **fields (Any): Additional data fields required for rendering.
+        """
+        with self._lock:
+            task = self._tasks[task_id]
+            completed_start = task.completed
+
+            if total is not None and total != task.total:
+                task.total = total
+                task._reset()
+            if advance is not None:
+                task.completed += advance
+            if completed is not None:
+                task.completed = completed
+            if description is not None:
+                task.description = description
+            if visible is not None:
+                task.visible = visible
+            task.fields.update(fields)
+            update_completed = task.completed - completed_start
+
+            current_time = self.get_time()
+            old_sample_time = current_time - self.speed_estimate_period
+            _progress = task._progress
+
+            popleft = _progress.popleft
+            while _progress and _progress[0].timestamp < old_sample_time:
+                popleft()
+            if update_completed > 0:
+                _progress.append(ProgressSample(current_time, update_completed))
+            if (
+                task.total is not None
+                and task.completed >= task.total
+                and task.finished_time is None
+            ):
+                task.finished_time = task.elapsed
+
+        if refresh:
+            self.refresh()
+
+    def reset(
+        self,
+        task_id: TaskID,
+        *,
+        start: bool = True,
+        total: Optional[float] = None,
+        completed: int = 0,
+        visible: Optional[bool] = None,
+        description: Optional[str] = None,
+        **fields: Any,
+    ) -> None:
+        """Reset a task so completed is 0 and the clock is reset.
+
+        Args:
+            task_id (TaskID): ID of task.
+            start (bool, optional): Start the task after reset. Defaults to True.
+            total (float, optional): New total steps in task, or None to use current total. Defaults to None.
+            completed (int, optional): Number of steps completed. Defaults to 0.
+            visible (bool, optional): Enable display of the task. Defaults to True.
+            description (str, optional): Change task description if not None. Defaults to None.
+            **fields (str): Additional data fields required for rendering.
+        """
+        current_time = self.get_time()
+        with self._lock:
+            task = self._tasks[task_id]
+            task._reset()
+            task.start_time = current_time if start else None
+            if total is not None:
+                task.total = total
+            task.completed = completed
+            if visible is not None:
+                task.visible = visible
+            if fields:
+                task.fields = fields
+            if description is not None:
+                task.description = description
+            task.finished_time = None
+        self.refresh()
+
+    def advance(self, task_id: TaskID, advance: float = 1) -> None:
+        """Advance task by a number of steps.
+
+        Args:
+            task_id (TaskID): ID of task.
+            advance (float): Number of steps to advance. Default is 1.
+        """
+        current_time = self.get_time()
+        with self._lock:
+            task = self._tasks[task_id]
+            completed_start = task.completed
+            task.completed += advance
+            update_completed = task.completed - completed_start
+            old_sample_time = current_time - self.speed_estimate_period
+            _progress = task._progress
+
+            popleft = _progress.popleft
+            while _progress and _progress[0].timestamp < old_sample_time:
+                popleft()
+            while len(_progress) > 1000:
+                popleft()
+            _progress.append(ProgressSample(current_time, update_completed))
+            if (
+                task.total is not None
+                and task.completed >= task.total
+                and task.finished_time is None
+            ):
+                task.finished_time = task.elapsed
+                task.finished_speed = task.speed
+
+    def refresh(self) -> None:
+        """Refresh (render) the progress information."""
+        if not self.disable and self.live.is_started:
+            self.live.refresh()
+
+    def get_renderable(self) -> RenderableType:
+        """Get a renderable for the progress display."""
+        renderable = Group(*self.get_renderables())
+        return renderable
+
+    def get_renderables(self) -> Iterable[RenderableType]:
+        """Get a number of renderables for the progress display."""
+        table = self.make_tasks_table(self.tasks)
+        yield table
+
+    def make_tasks_table(self, tasks: Iterable[Task]) -> Table:
+        """Get a table to render the Progress display.
+
+        Args:
+            tasks (Iterable[Task]): An iterable of Task instances, one per row of the table.
+
+        Returns:
+            Table: A table instance.
+        """
+        table_columns = (
+            (
+                Column(no_wrap=True)
+                if isinstance(_column, str)
+                else _column.get_table_column().copy()
+            )
+            for _column in self.columns
+        )
+        table = Table.grid(*table_columns, padding=(0, 1), expand=self.expand)
+
+        for task in tasks:
+            if task.visible:
+                table.add_row(
+                    *(
+                        (
+                            column.format(task=task)
+                            if isinstance(column, str)
+                            else column(task)
+                        )
+                        for column in self.columns
+                    )
+                )
+        return table
+
+    def __rich__(self) -> RenderableType:
+        """Makes the Progress class itself renderable."""
+        with self._lock:
+            return self.get_renderable()
+
+    def add_task(
+        self,
+        description: str,
+        start: bool = True,
+        total: Optional[float] = 100.0,
+        completed: int = 0,
+        visible: bool = True,
+        **fields: Any,
+    ) -> TaskID:
+        """Add a new 'task' to the Progress display.
+
+        Args:
+            description (str): A description of the task.
+            start (bool, optional): Start the task immediately (to calculate elapsed time). If set to False,
+                you will need to call `start` manually. Defaults to True.
+            total (float, optional): Number of total steps in the progress if known.
+                Set to None to render a pulsing animation. Defaults to 100.
+            completed (int, optional): Number of steps completed so far. Defaults to 0.
+            visible (bool, optional): Enable display of the task. Defaults to True.
+            **fields (str): Additional data fields required for rendering.
+
+        Returns:
+            TaskID: An ID you can use when calling `update`.
+        """
+        with self._lock:
+            task = Task(
+                self._task_index,
+                description,
+                total,
+                completed,
+                visible=visible,
+                fields=fields,
+                _get_time=self.get_time,
+                _lock=self._lock,
+            )
+            self._tasks[self._task_index] = task
+            if start:
+                self.start_task(self._task_index)
+            new_task_index = self._task_index
+            self._task_index = TaskID(int(self._task_index) + 1)
+        self.refresh()
+        return new_task_index
+
+    def remove_task(self, task_id: TaskID) -> None:
+        """Delete a task if it exists.
+
+        Args:
+            task_id (TaskID): A task ID.
+
+        """
+        with self._lock:
+            del self._tasks[task_id]
+
+
+if __name__ == "__main__":  # pragma: no coverage
+    import random
+    import time
+
+    from .panel import Panel
+    from .rule import Rule
+    from .syntax import Syntax
+    from .table import Table
+
+    syntax = Syntax(
+        '''def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value''',
+        "python",
+        line_numbers=True,
+    )
+
+    table = Table("foo", "bar", "baz")
+    table.add_row("1", "2", "3")
+
+    progress_renderables = [
+        "Text may be printed while the progress bars are rendering.",
+        Panel("In fact, [i]any[/i] renderable will work"),
+        "Such as [magenta]tables[/]...",
+        table,
+        "Pretty printed structures...",
+        {"type": "example", "text": "Pretty printed"},
+        "Syntax...",
+        syntax,
+        Rule("Give it a try!"),
+    ]
+
+    from itertools import cycle
+
+    examples = cycle(progress_renderables)
+
+    console = Console(record=True)
+
+    with Progress(
+        SpinnerColumn(),
+        *Progress.get_default_columns(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=False,
+    ) as progress:
+        task1 = progress.add_task("[red]Downloading", total=1000)
+        task2 = progress.add_task("[green]Processing", total=1000)
+        task3 = progress.add_task("[yellow]Thinking", total=None)
+
+        while not progress.finished:
+            progress.update(task1, advance=0.5)
+            progress.update(task2, advance=0.3)
+            time.sleep(0.01)
+            if random.randint(0, 100) < 1:
+                progress.log(next(examples))

llava/lib/python3.10/site-packages/pip/_vendor/rich/repr.py

@@ -0,0 +1,149 @@
+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)

llava/lib/python3.10/site-packages/pip/_vendor/rich/rule.py

@@ -0,0 +1,130 @@
+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)

llava/lib/python3.10/site-packages/pip/_vendor/rich/screen.py

@@ -0,0 +1,54 @@
+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

llava/lib/python3.10/site-packages/pip/_vendor/rich/spinner.py

@@ -0,0 +1,138 @@
+from typing import cast, List, Optional, TYPE_CHECKING, Union
+
+from ._spinners import SPINNERS
+from .measure import Measurement
+from .table import Table
+from .text import Text
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderResult, RenderableType
+    from .style import StyleType
+
+
+class Spinner:
+    """A spinner animation.
+
+    Args:
+        name (str): Name of spinner (run python -m rich.spinner).
+        text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to "".
+        style (StyleType, optional): Style for spinner animation. Defaults to None.
+        speed (float, optional): Speed factor for animation. Defaults to 1.0.
+
+    Raises:
+        KeyError: If name isn't one of the supported spinner animations.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        text: "RenderableType" = "",
+        *,
+        style: Optional["StyleType"] = None,
+        speed: float = 1.0,
+    ) -> None:
+        try:
+            spinner = SPINNERS[name]
+        except KeyError:
+            raise KeyError(f"no spinner called {name!r}")
+        self.text: "Union[RenderableType, Text]" = (
+            Text.from_markup(text) if isinstance(text, str) else text
+        )
+        self.name = name
+        self.frames = cast(List[str], spinner["frames"])[:]
+        self.interval = cast(float, spinner["interval"])
+        self.start_time: Optional[float] = None
+        self.style = style
+        self.speed = speed
+        self.frame_no_offset: float = 0.0
+        self._update_speed = 0.0
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        yield self.render(console.get_time())
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Measurement:
+        text = self.render(0)
+        return Measurement.get(console, options, text)
+
+    def render(self, time: float) -> "RenderableType":
+        """Render the spinner for a given time.
+
+        Args:
+            time (float): Time in seconds.
+
+        Returns:
+            RenderableType: A renderable containing animation frame.
+        """
+        if self.start_time is None:
+            self.start_time = time
+
+        frame_no = ((time - self.start_time) * self.speed) / (
+            self.interval / 1000.0
+        ) + self.frame_no_offset
+        frame = Text(
+            self.frames[int(frame_no) % len(self.frames)], style=self.style or ""
+        )
+
+        if self._update_speed:
+            self.frame_no_offset = frame_no
+            self.start_time = time
+            self.speed = self._update_speed
+            self._update_speed = 0.0
+
+        if not self.text:
+            return frame
+        elif isinstance(self.text, (str, Text)):
+            return Text.assemble(frame, " ", self.text)
+        else:
+            table = Table.grid(padding=1)
+            table.add_row(frame, self.text)
+            return table
+
+    def update(
+        self,
+        *,
+        text: "RenderableType" = "",
+        style: Optional["StyleType"] = None,
+        speed: Optional[float] = None,
+    ) -> None:
+        """Updates attributes of a spinner after it has been started.
+
+        Args:
+            text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to "".
+            style (StyleType, optional): Style for spinner animation. Defaults to None.
+            speed (float, optional): Speed factor for animation. Defaults to None.
+        """
+        if text:
+            self.text = Text.from_markup(text) if isinstance(text, str) else text
+        if style:
+            self.style = style
+        if speed:
+            self._update_speed = speed
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from time import sleep
+
+    from .columns import Columns
+    from .panel import Panel
+    from .live import Live
+
+    all_spinners = Columns(
+        [
+            Spinner(spinner_name, text=Text(repr(spinner_name), style="green"))
+            for spinner_name in sorted(SPINNERS.keys())
+        ],
+        column_first=True,
+        expand=True,
+    )
+
+    with Live(
+        Panel(all_spinners, title="Spinners", border_style="blue"),
+        refresh_per_second=20,
+    ) as live:
+        while True:
+            sleep(0.1)

llava/lib/python3.10/site-packages/pip/_vendor/rich/syntax.py

@@ -0,0 +1,966 @@
+import os.path
+import re
+import sys
+import textwrap
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+from pip._vendor.pygments.lexer import Lexer
+from pip._vendor.pygments.lexers import get_lexer_by_name, guess_lexer_for_filename
+from pip._vendor.pygments.style import Style as PygmentsStyle
+from pip._vendor.pygments.styles import get_style_by_name
+from pip._vendor.pygments.token import (
+    Comment,
+    Error,
+    Generic,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    String,
+    Token,
+    Whitespace,
+)
+from pip._vendor.pygments.util import ClassNotFound
+
+from pip._vendor.rich.containers import Lines
+from pip._vendor.rich.padding import Padding, PaddingDimensions
+
+from ._loop import loop_first
+from .cells import cell_len
+from .color import Color, blend_rgb
+from .console import Console, ConsoleOptions, JustifyMethod, RenderResult
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .segment import Segment, Segments
+from .style import Style, StyleType
+from .text import Text
+
+TokenType = Tuple[str, ...]
+
+WINDOWS = sys.platform == "win32"
+DEFAULT_THEME = "monokai"
+
+# The following styles are based on https://github.com/pygments/pygments/blob/master/pygments/formatters/terminal.py
+# A few modifications were made
+
+ANSI_LIGHT: Dict[TokenType, Style] = {
+    Token: Style(),
+    Whitespace: Style(color="white"),
+    Comment: Style(dim=True),
+    Comment.Preproc: Style(color="cyan"),
+    Keyword: Style(color="blue"),
+    Keyword.Type: Style(color="cyan"),
+    Operator.Word: Style(color="magenta"),
+    Name.Builtin: Style(color="cyan"),
+    Name.Function: Style(color="green"),
+    Name.Namespace: Style(color="cyan", underline=True),
+    Name.Class: Style(color="green", underline=True),
+    Name.Exception: Style(color="cyan"),
+    Name.Decorator: Style(color="magenta", bold=True),
+    Name.Variable: Style(color="red"),
+    Name.Constant: Style(color="red"),
+    Name.Attribute: Style(color="cyan"),
+    Name.Tag: Style(color="bright_blue"),
+    String: Style(color="yellow"),
+    Number: Style(color="blue"),
+    Generic.Deleted: Style(color="bright_red"),
+    Generic.Inserted: Style(color="green"),
+    Generic.Heading: Style(bold=True),
+    Generic.Subheading: Style(color="magenta", bold=True),
+    Generic.Prompt: Style(bold=True),
+    Generic.Error: Style(color="bright_red"),
+    Error: Style(color="red", underline=True),
+}
+
+ANSI_DARK: Dict[TokenType, Style] = {
+    Token: Style(),
+    Whitespace: Style(color="bright_black"),
+    Comment: Style(dim=True),
+    Comment.Preproc: Style(color="bright_cyan"),
+    Keyword: Style(color="bright_blue"),
+    Keyword.Type: Style(color="bright_cyan"),
+    Operator.Word: Style(color="bright_magenta"),
+    Name.Builtin: Style(color="bright_cyan"),
+    Name.Function: Style(color="bright_green"),
+    Name.Namespace: Style(color="bright_cyan", underline=True),
+    Name.Class: Style(color="bright_green", underline=True),
+    Name.Exception: Style(color="bright_cyan"),
+    Name.Decorator: Style(color="bright_magenta", bold=True),
+    Name.Variable: Style(color="bright_red"),
+    Name.Constant: Style(color="bright_red"),
+    Name.Attribute: Style(color="bright_cyan"),
+    Name.Tag: Style(color="bright_blue"),
+    String: Style(color="yellow"),
+    Number: Style(color="bright_blue"),
+    Generic.Deleted: Style(color="bright_red"),
+    Generic.Inserted: Style(color="bright_green"),
+    Generic.Heading: Style(bold=True),
+    Generic.Subheading: Style(color="bright_magenta", bold=True),
+    Generic.Prompt: Style(bold=True),
+    Generic.Error: Style(color="bright_red"),
+    Error: Style(color="red", underline=True),
+}
+
+RICH_SYNTAX_THEMES = {"ansi_light": ANSI_LIGHT, "ansi_dark": ANSI_DARK}
+NUMBERS_COLUMN_DEFAULT_PADDING = 2
+
+
+class SyntaxTheme(ABC):
+    """Base class for a syntax theme."""
+
+    @abstractmethod
+    def get_style_for_token(self, token_type: TokenType) -> Style:
+        """Get a style for a given Pygments token."""
+        raise NotImplementedError  # pragma: no cover
+
+    @abstractmethod
+    def get_background_style(self) -> Style:
+        """Get the background color."""
+        raise NotImplementedError  # pragma: no cover
+
+
+class PygmentsSyntaxTheme(SyntaxTheme):
+    """Syntax theme that delegates to Pygments theme."""
+
+    def __init__(self, theme: Union[str, Type[PygmentsStyle]]) -> None:
+        self._style_cache: Dict[TokenType, Style] = {}
+        if isinstance(theme, str):
+            try:
+                self._pygments_style_class = get_style_by_name(theme)
+            except ClassNotFound:
+                self._pygments_style_class = get_style_by_name("default")
+        else:
+            self._pygments_style_class = theme
+
+        self._background_color = self._pygments_style_class.background_color
+        self._background_style = Style(bgcolor=self._background_color)
+
+    def get_style_for_token(self, token_type: TokenType) -> Style:
+        """Get a style from a Pygments class."""
+        try:
+            return self._style_cache[token_type]
+        except KeyError:
+            try:
+                pygments_style = self._pygments_style_class.style_for_token(token_type)
+            except KeyError:
+                style = Style.null()
+            else:
+                color = pygments_style["color"]
+                bgcolor = pygments_style["bgcolor"]
+                style = Style(
+                    color="#" + color if color else "#000000",
+                    bgcolor="#" + bgcolor if bgcolor else self._background_color,
+                    bold=pygments_style["bold"],
+                    italic=pygments_style["italic"],
+                    underline=pygments_style["underline"],
+                )
+            self._style_cache[token_type] = style
+        return style
+
+    def get_background_style(self) -> Style:
+        return self._background_style
+
+
+class ANSISyntaxTheme(SyntaxTheme):
+    """Syntax theme to use standard colors."""
+
+    def __init__(self, style_map: Dict[TokenType, Style]) -> None:
+        self.style_map = style_map
+        self._missing_style = Style.null()
+        self._background_style = Style.null()
+        self._style_cache: Dict[TokenType, Style] = {}
+
+    def get_style_for_token(self, token_type: TokenType) -> Style:
+        """Look up style in the style map."""
+        try:
+            return self._style_cache[token_type]
+        except KeyError:
+            # Styles form a hierarchy
+            # We need to go from most to least specific
+            # e.g. ("foo", "bar", "baz") to ("foo", "bar")  to ("foo",)
+            get_style = self.style_map.get
+            token = tuple(token_type)
+            style = self._missing_style
+            while token:
+                _style = get_style(token)
+                if _style is not None:
+                    style = _style
+                    break
+                token = token[:-1]
+            self._style_cache[token_type] = style
+            return style
+
+    def get_background_style(self) -> Style:
+        return self._background_style
+
+
+SyntaxPosition = Tuple[int, int]
+
+
+class _SyntaxHighlightRange(NamedTuple):
+    """
+    A range to highlight in a Syntax object.
+    `start` and `end` are 2-integers tuples, where the first integer is the line number
+    (starting from 1) and the second integer is the column index (starting from 0).
+    """
+
+    style: StyleType
+    start: SyntaxPosition
+    end: SyntaxPosition
+    style_before: bool = False
+
+
+class Syntax(JupyterMixin):
+    """Construct a Syntax object to render syntax highlighted code.
+
+    Args:
+        code (str): Code to highlight.
+        lexer (Lexer | str): Lexer to use (see https://pygments.org/docs/lexers/)
+        theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to "monokai".
+        dedent (bool, optional): Enable stripping of initial whitespace. Defaults to False.
+        line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.
+        start_line (int, optional): Starting number for line numbers. Defaults to 1.
+        line_range (Tuple[int | None, int | None], optional): If given should be a tuple of the start and end line to render.
+            A value of None in the tuple indicates the range is open in that direction.
+        highlight_lines (Set[int]): A set of line numbers to highlight.
+        code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.
+        tab_size (int, optional): Size of tabs. Defaults to 4.
+        word_wrap (bool, optional): Enable word wrapping.
+        background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.
+        indent_guides (bool, optional): Show indent guides. Defaults to False.
+        padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).
+    """
+
+    _pygments_style_class: Type[PygmentsStyle]
+    _theme: SyntaxTheme
+
+    @classmethod
+    def get_theme(cls, name: Union[str, SyntaxTheme]) -> SyntaxTheme:
+        """Get a syntax theme instance."""
+        if isinstance(name, SyntaxTheme):
+            return name
+        theme: SyntaxTheme
+        if name in RICH_SYNTAX_THEMES:
+            theme = ANSISyntaxTheme(RICH_SYNTAX_THEMES[name])
+        else:
+            theme = PygmentsSyntaxTheme(name)
+        return theme
+
+    def __init__(
+        self,
+        code: str,
+        lexer: Union[Lexer, str],
+        *,
+        theme: Union[str, SyntaxTheme] = DEFAULT_THEME,
+        dedent: bool = False,
+        line_numbers: bool = False,
+        start_line: int = 1,
+        line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,
+        highlight_lines: Optional[Set[int]] = None,
+        code_width: Optional[int] = None,
+        tab_size: int = 4,
+        word_wrap: bool = False,
+        background_color: Optional[str] = None,
+        indent_guides: bool = False,
+        padding: PaddingDimensions = 0,
+    ) -> None:
+        self.code = code
+        self._lexer = lexer
+        self.dedent = dedent
+        self.line_numbers = line_numbers
+        self.start_line = start_line
+        self.line_range = line_range
+        self.highlight_lines = highlight_lines or set()
+        self.code_width = code_width
+        self.tab_size = tab_size
+        self.word_wrap = word_wrap
+        self.background_color = background_color
+        self.background_style = (
+            Style(bgcolor=background_color) if background_color else Style()
+        )
+        self.indent_guides = indent_guides
+        self.padding = padding
+
+        self._theme = self.get_theme(theme)
+        self._stylized_ranges: List[_SyntaxHighlightRange] = []
+
+    @classmethod
+    def from_path(
+        cls,
+        path: str,
+        encoding: str = "utf-8",
+        lexer: Optional[Union[Lexer, str]] = None,
+        theme: Union[str, SyntaxTheme] = DEFAULT_THEME,
+        dedent: bool = False,
+        line_numbers: bool = False,
+        line_range: Optional[Tuple[int, int]] = None,
+        start_line: int = 1,
+        highlight_lines: Optional[Set[int]] = None,
+        code_width: Optional[int] = None,
+        tab_size: int = 4,
+        word_wrap: bool = False,
+        background_color: Optional[str] = None,
+        indent_guides: bool = False,
+        padding: PaddingDimensions = 0,
+    ) -> "Syntax":
+        """Construct a Syntax object from a file.
+
+        Args:
+            path (str): Path to file to highlight.
+            encoding (str): Encoding of file.
+            lexer (str | Lexer, optional): Lexer to use. If None, lexer will be auto-detected from path/file content.
+            theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to "emacs".
+            dedent (bool, optional): Enable stripping of initial whitespace. Defaults to True.
+            line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.
+            start_line (int, optional): Starting number for line numbers. Defaults to 1.
+            line_range (Tuple[int, int], optional): If given should be a tuple of the start and end line to render.
+            highlight_lines (Set[int]): A set of line numbers to highlight.
+            code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.
+            tab_size (int, optional): Size of tabs. Defaults to 4.
+            word_wrap (bool, optional): Enable word wrapping of code.
+            background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.
+            indent_guides (bool, optional): Show indent guides. Defaults to False.
+            padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).
+
+        Returns:
+            [Syntax]: A Syntax object that may be printed to the console
+        """
+        code = Path(path).read_text(encoding=encoding)
+
+        if not lexer:
+            lexer = cls.guess_lexer(path, code=code)
+
+        return cls(
+            code,
+            lexer,
+            theme=theme,
+            dedent=dedent,
+            line_numbers=line_numbers,
+            line_range=line_range,
+            start_line=start_line,
+            highlight_lines=highlight_lines,
+            code_width=code_width,
+            tab_size=tab_size,
+            word_wrap=word_wrap,
+            background_color=background_color,
+            indent_guides=indent_guides,
+            padding=padding,
+        )
+
+    @classmethod
+    def guess_lexer(cls, path: str, code: Optional[str] = None) -> str:
+        """Guess the alias of the Pygments lexer to use based on a path and an optional string of code.
+        If code is supplied, it will use a combination of the code and the filename to determine the
+        best lexer to use. For example, if the file is ``index.html`` and the file contains Django
+        templating syntax, then "html+django" will be returned. If the file is ``index.html``, and no
+        templating language is used, the "html" lexer will be used. If no string of code
+        is supplied, the lexer will be chosen based on the file extension..
+
+        Args:
+             path (AnyStr): The path to the file containing the code you wish to know the lexer for.
+             code (str, optional): Optional string of code that will be used as a fallback if no lexer
+                is found for the supplied path.
+
+        Returns:
+            str: The name of the Pygments lexer that best matches the supplied path/code.
+        """
+        lexer: Optional[Lexer] = None
+        lexer_name = "default"
+        if code:
+            try:
+                lexer = guess_lexer_for_filename(path, code)
+            except ClassNotFound:
+                pass
+
+        if not lexer:
+            try:
+                _, ext = os.path.splitext(path)
+                if ext:
+                    extension = ext.lstrip(".").lower()
+                    lexer = get_lexer_by_name(extension)
+            except ClassNotFound:
+                pass
+
+        if lexer:
+            if lexer.aliases:
+                lexer_name = lexer.aliases[0]
+            else:
+                lexer_name = lexer.name
+
+        return lexer_name
+
+    def _get_base_style(self) -> Style:
+        """Get the base style."""
+        default_style = self._theme.get_background_style() + self.background_style
+        return default_style
+
+    def _get_token_color(self, token_type: TokenType) -> Optional[Color]:
+        """Get a color (if any) for the given token.
+
+        Args:
+            token_type (TokenType): A token type tuple from Pygments.
+
+        Returns:
+            Optional[Color]: Color from theme, or None for no color.
+        """
+        style = self._theme.get_style_for_token(token_type)
+        return style.color
+
+    @property
+    def lexer(self) -> Optional[Lexer]:
+        """The lexer for this syntax, or None if no lexer was found.
+
+        Tries to find the lexer by name if a string was passed to the constructor.
+        """
+
+        if isinstance(self._lexer, Lexer):
+            return self._lexer
+        try:
+            return get_lexer_by_name(
+                self._lexer,
+                stripnl=False,
+                ensurenl=True,
+                tabsize=self.tab_size,
+            )
+        except ClassNotFound:
+            return None
+
+    @property
+    def default_lexer(self) -> Lexer:
+        """A Pygments Lexer to use if one is not specified or invalid."""
+        return get_lexer_by_name(
+            "text",
+            stripnl=False,
+            ensurenl=True,
+            tabsize=self.tab_size,
+        )
+
+    def highlight(
+        self,
+        code: str,
+        line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,
+    ) -> Text:
+        """Highlight code and return a Text instance.
+
+        Args:
+            code (str): Code to highlight.
+            line_range(Tuple[int, int], optional): Optional line range to highlight.
+
+        Returns:
+            Text: A text instance containing highlighted syntax.
+        """
+
+        base_style = self._get_base_style()
+        justify: JustifyMethod = (
+            "default" if base_style.transparent_background else "left"
+        )
+
+        text = Text(
+            justify=justify,
+            style=base_style,
+            tab_size=self.tab_size,
+            no_wrap=not self.word_wrap,
+        )
+        _get_theme_style = self._theme.get_style_for_token
+
+        lexer = self.lexer or self.default_lexer
+
+        if lexer is None:
+            text.append(code)
+        else:
+            if line_range:
+                # More complicated path to only stylize a portion of the code
+                # This speeds up further operations as there are less spans to process
+                line_start, line_end = line_range
+
+                def line_tokenize() -> Iterable[Tuple[Any, str]]:
+                    """Split tokens to one per line."""
+                    assert lexer  # required to make MyPy happy - we know lexer is not None at this point
+
+                    for token_type, token in lexer.get_tokens(code):
+                        while token:
+                            line_token, new_line, token = token.partition("\n")
+                            yield token_type, line_token + new_line
+
+                def tokens_to_spans() -> Iterable[Tuple[str, Optional[Style]]]:
+                    """Convert tokens to spans."""
+                    tokens = iter(line_tokenize())
+                    line_no = 0
+                    _line_start = line_start - 1 if line_start else 0
+
+                    # Skip over tokens until line start
+                    while line_no < _line_start:
+                        try:
+                            _token_type, token = next(tokens)
+                        except StopIteration:
+                            break
+                        yield (token, None)
+                        if token.endswith("\n"):
+                            line_no += 1
+                    # Generate spans until line end
+                    for token_type, token in tokens:
+                        yield (token, _get_theme_style(token_type))
+                        if token.endswith("\n"):
+                            line_no += 1
+                            if line_end and line_no >= line_end:
+                                break
+
+                text.append_tokens(tokens_to_spans())
+
+            else:
+                text.append_tokens(
+                    (token, _get_theme_style(token_type))
+                    for token_type, token in lexer.get_tokens(code)
+                )
+            if self.background_color is not None:
+                text.stylize(f"on {self.background_color}")
+
+        if self._stylized_ranges:
+            self._apply_stylized_ranges(text)
+
+        return text
+
+    def stylize_range(
+        self,
+        style: StyleType,
+        start: SyntaxPosition,
+        end: SyntaxPosition,
+        style_before: bool = False,
+    ) -> None:
+        """
+        Adds a custom style on a part of the code, that will be applied to the syntax display when it's rendered.
+        Line numbers are 1-based, while column indexes are 0-based.
+
+        Args:
+            style (StyleType): The style to apply.
+            start (Tuple[int, int]): The start of the range, in the form `[line number, column index]`.
+            end (Tuple[int, int]): The end of the range, in the form `[line number, column index]`.
+            style_before (bool): Apply the style before any existing styles.
+        """
+        self._stylized_ranges.append(
+            _SyntaxHighlightRange(style, start, end, style_before)
+        )
+
+    def _get_line_numbers_color(self, blend: float = 0.3) -> Color:
+        background_style = self._theme.get_background_style() + self.background_style
+        background_color = background_style.bgcolor
+        if background_color is None or background_color.is_system_defined:
+            return Color.default()
+        foreground_color = self._get_token_color(Token.Text)
+        if foreground_color is None or foreground_color.is_system_defined:
+            return foreground_color or Color.default()
+        new_color = blend_rgb(
+            background_color.get_truecolor(),
+            foreground_color.get_truecolor(),
+            cross_fade=blend,
+        )
+        return Color.from_triplet(new_color)
+
+    @property
+    def _numbers_column_width(self) -> int:
+        """Get the number of characters used to render the numbers column."""
+        column_width = 0
+        if self.line_numbers:
+            column_width = (
+                len(str(self.start_line + self.code.count("\n")))
+                + NUMBERS_COLUMN_DEFAULT_PADDING
+            )
+        return column_width
+
+    def _get_number_styles(self, console: Console) -> Tuple[Style, Style, Style]:
+        """Get background, number, and highlight styles for line numbers."""
+        background_style = self._get_base_style()
+        if background_style.transparent_background:
+            return Style.null(), Style(dim=True), Style.null()
+        if console.color_system in ("256", "truecolor"):
+            number_style = Style.chain(
+                background_style,
+                self._theme.get_style_for_token(Token.Text),
+                Style(color=self._get_line_numbers_color()),
+                self.background_style,
+            )
+            highlight_number_style = Style.chain(
+                background_style,
+                self._theme.get_style_for_token(Token.Text),
+                Style(bold=True, color=self._get_line_numbers_color(0.9)),
+                self.background_style,
+            )
+        else:
+            number_style = background_style + Style(dim=True)
+            highlight_number_style = background_style + Style(dim=False)
+        return background_style, number_style, highlight_number_style
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        _, right, _, left = Padding.unpack(self.padding)
+        padding = left + right
+        if self.code_width is not None:
+            width = self.code_width + self._numbers_column_width + padding + 1
+            return Measurement(self._numbers_column_width, width)
+        lines = self.code.splitlines()
+        width = (
+            self._numbers_column_width
+            + padding
+            + (max(cell_len(line) for line in lines) if lines else 0)
+        )
+        if self.line_numbers:
+            width += 1
+        return Measurement(self._numbers_column_width, width)
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        segments = Segments(self._get_syntax(console, options))
+        if self.padding:
+            yield Padding(segments, style=self._get_base_style(), pad=self.padding)
+        else:
+            yield segments
+
+    def _get_syntax(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> Iterable[Segment]:
+        """
+        Get the Segments for the Syntax object, excluding any vertical/horizontal padding
+        """
+        transparent_background = self._get_base_style().transparent_background
+        code_width = (
+            (
+                (options.max_width - self._numbers_column_width - 1)
+                if self.line_numbers
+                else options.max_width
+            )
+            if self.code_width is None
+            else self.code_width
+        )
+
+        ends_on_nl, processed_code = self._process_code(self.code)
+        text = self.highlight(processed_code, self.line_range)
+
+        if not self.line_numbers and not self.word_wrap and not self.line_range:
+            if not ends_on_nl:
+                text.remove_suffix("\n")
+            # Simple case of just rendering text
+            style = (
+                self._get_base_style()
+                + self._theme.get_style_for_token(Comment)
+                + Style(dim=True)
+                + self.background_style
+            )
+            if self.indent_guides and not options.ascii_only:
+                text = text.with_indent_guides(self.tab_size, style=style)
+                text.overflow = "crop"
+            if style.transparent_background:
+                yield from console.render(
+                    text, options=options.update(width=code_width)
+                )
+            else:
+                syntax_lines = console.render_lines(
+                    text,
+                    options.update(width=code_width, height=None, justify="left"),
+                    style=self.background_style,
+                    pad=True,
+                    new_lines=True,
+                )
+                for syntax_line in syntax_lines:
+                    yield from syntax_line
+            return
+
+        start_line, end_line = self.line_range or (None, None)
+        line_offset = 0
+        if start_line:
+            line_offset = max(0, start_line - 1)
+        lines: Union[List[Text], Lines] = text.split("\n", allow_blank=ends_on_nl)
+        if self.line_range:
+            if line_offset > len(lines):
+                return
+            lines = lines[line_offset:end_line]
+
+        if self.indent_guides and not options.ascii_only:
+            style = (
+                self._get_base_style()
+                + self._theme.get_style_for_token(Comment)
+                + Style(dim=True)
+                + self.background_style
+            )
+            lines = (
+                Text("\n")
+                .join(lines)
+                .with_indent_guides(self.tab_size, style=style + Style(italic=False))
+                .split("\n", allow_blank=True)
+            )
+
+        numbers_column_width = self._numbers_column_width
+        render_options = options.update(width=code_width)
+
+        highlight_line = self.highlight_lines.__contains__
+        _Segment = Segment
+        new_line = _Segment("\n")
+
+        line_pointer = "> " if options.legacy_windows else "❱ "
+
+        (
+            background_style,
+            number_style,
+            highlight_number_style,
+        ) = self._get_number_styles(console)
+
+        for line_no, line in enumerate(lines, self.start_line + line_offset):
+            if self.word_wrap:
+                wrapped_lines = console.render_lines(
+                    line,
+                    render_options.update(height=None, justify="left"),
+                    style=background_style,
+                    pad=not transparent_background,
+                )
+            else:
+                segments = list(line.render(console, end=""))
+                if options.no_wrap:
+                    wrapped_lines = [segments]
+                else:
+                    wrapped_lines = [
+                        _Segment.adjust_line_length(
+                            segments,
+                            render_options.max_width,
+                            style=background_style,
+                            pad=not transparent_background,
+                        )
+                    ]
+
+            if self.line_numbers:
+                wrapped_line_left_pad = _Segment(
+                    " " * numbers_column_width + " ", background_style
+                )
+                for first, wrapped_line in loop_first(wrapped_lines):
+                    if first:
+                        line_column = str(line_no).rjust(numbers_column_width - 2) + " "
+                        if highlight_line(line_no):
+                            yield _Segment(line_pointer, Style(color="red"))
+                            yield _Segment(line_column, highlight_number_style)
+                        else:
+                            yield _Segment("  ", highlight_number_style)
+                            yield _Segment(line_column, number_style)
+                    else:
+                        yield wrapped_line_left_pad
+                    yield from wrapped_line
+                    yield new_line
+            else:
+                for wrapped_line in wrapped_lines:
+                    yield from wrapped_line
+                    yield new_line
+
+    def _apply_stylized_ranges(self, text: Text) -> None:
+        """
+        Apply stylized ranges to a text instance,
+        using the given code to determine the right portion to apply the style to.
+
+        Args:
+            text (Text): Text instance to apply the style to.
+        """
+        code = text.plain
+        newlines_offsets = [
+            # Let's add outer boundaries at each side of the list:
+            0,
+            # N.B. using "\n" here is much faster than using metacharacters such as "^" or "\Z":
+            *[
+                match.start() + 1
+                for match in re.finditer("\n", code, flags=re.MULTILINE)
+            ],
+            len(code) + 1,
+        ]
+
+        for stylized_range in self._stylized_ranges:
+            start = _get_code_index_for_syntax_position(
+                newlines_offsets, stylized_range.start
+            )
+            end = _get_code_index_for_syntax_position(
+                newlines_offsets, stylized_range.end
+            )
+            if start is not None and end is not None:
+                if stylized_range.style_before:
+                    text.stylize_before(stylized_range.style, start, end)
+                else:
+                    text.stylize(stylized_range.style, start, end)
+
+    def _process_code(self, code: str) -> Tuple[bool, str]:
+        """
+        Applies various processing to a raw code string
+        (normalises it so it always ends with a line return, dedents it if necessary, etc.)
+
+        Args:
+            code (str): The raw code string to process
+
+        Returns:
+            Tuple[bool, str]: the boolean indicates whether the raw code ends with a line return,
+                while the string is the processed code.
+        """
+        ends_on_nl = code.endswith("\n")
+        processed_code = code if ends_on_nl else code + "\n"
+        processed_code = (
+            textwrap.dedent(processed_code) if self.dedent else processed_code
+        )
+        processed_code = processed_code.expandtabs(self.tab_size)
+        return ends_on_nl, processed_code
+
+
+def _get_code_index_for_syntax_position(
+    newlines_offsets: Sequence[int], position: SyntaxPosition
+) -> Optional[int]:
+    """
+    Returns the index of the code string for the given positions.
+
+    Args:
+        newlines_offsets (Sequence[int]): The offset of each newline character found in the code snippet.
+        position (SyntaxPosition): The position to search for.
+
+    Returns:
+        Optional[int]: The index of the code string for this position, or `None`
+            if the given position's line number is out of range (if it's the column that is out of range
+            we silently clamp its value so that it reaches the end of the line)
+    """
+    lines_count = len(newlines_offsets)
+
+    line_number, column_index = position
+    if line_number > lines_count or len(newlines_offsets) < (line_number + 1):
+        return None  # `line_number` is out of range
+    line_index = line_number - 1
+    line_length = newlines_offsets[line_index + 1] - newlines_offsets[line_index] - 1
+    # If `column_index` is out of range: let's silently clamp it:
+    column_index = min(line_length, column_index)
+    return newlines_offsets[line_index] + column_index
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(
+        description="Render syntax to the console with Rich"
+    )
+    parser.add_argument(
+        "path",
+        metavar="PATH",
+        help="path to file, or - for stdin",
+    )
+    parser.add_argument(
+        "-c",
+        "--force-color",
+        dest="force_color",
+        action="store_true",
+        default=None,
+        help="force color for non-terminals",
+    )
+    parser.add_argument(
+        "-i",
+        "--indent-guides",
+        dest="indent_guides",
+        action="store_true",
+        default=False,
+        help="display indent guides",
+    )
+    parser.add_argument(
+        "-l",
+        "--line-numbers",
+        dest="line_numbers",
+        action="store_true",
+        help="render line numbers",
+    )
+    parser.add_argument(
+        "-w",
+        "--width",
+        type=int,
+        dest="width",
+        default=None,
+        help="width of output (default will auto-detect)",
+    )
+    parser.add_argument(
+        "-r",
+        "--wrap",
+        dest="word_wrap",
+        action="store_true",
+        default=False,
+        help="word wrap long lines",
+    )
+    parser.add_argument(
+        "-s",
+        "--soft-wrap",
+        action="store_true",
+        dest="soft_wrap",
+        default=False,
+        help="enable soft wrapping mode",
+    )
+    parser.add_argument(
+        "-t", "--theme", dest="theme", default="monokai", help="pygments theme"
+    )
+    parser.add_argument(
+        "-b",
+        "--background-color",
+        dest="background_color",
+        default=None,
+        help="Override background color",
+    )
+    parser.add_argument(
+        "-x",
+        "--lexer",
+        default=None,
+        dest="lexer_name",
+        help="Lexer name",
+    )
+    parser.add_argument(
+        "-p", "--padding", type=int, default=0, dest="padding", help="Padding"
+    )
+    parser.add_argument(
+        "--highlight-line",
+        type=int,
+        default=None,
+        dest="highlight_line",
+        help="The line number (not index!) to highlight",
+    )
+    args = parser.parse_args()
+
+    from pip._vendor.rich.console import Console
+
+    console = Console(force_terminal=args.force_color, width=args.width)
+
+    if args.path == "-":
+        code = sys.stdin.read()
+        syntax = Syntax(
+            code=code,
+            lexer=args.lexer_name,
+            line_numbers=args.line_numbers,
+            word_wrap=args.word_wrap,
+            theme=args.theme,
+            background_color=args.background_color,
+            indent_guides=args.indent_guides,
+            padding=args.padding,
+            highlight_lines={args.highlight_line},
+        )
+    else:
+        syntax = Syntax.from_path(
+            args.path,
+            lexer=args.lexer_name,
+            line_numbers=args.line_numbers,
+            word_wrap=args.word_wrap,
+            theme=args.theme,
+            background_color=args.background_color,
+            indent_guides=args.indent_guides,
+            padding=args.padding,
+            highlight_lines={args.highlight_line},
+        )
+    console.print(syntax, soft_wrap=args.soft_wrap)

llava/lib/python3.10/site-packages/pip/_vendor/rich/terminal_theme.py

@@ -0,0 +1,153 @@
+from typing import List, Optional, Tuple
+
+from .color_triplet import ColorTriplet
+from .palette import Palette
+
+_ColorTuple = Tuple[int, int, int]
+
+
+class TerminalTheme:
+    """A color theme used when exporting console content.
+
+    Args:
+        background (Tuple[int, int, int]): The background color.
+        foreground (Tuple[int, int, int]): The foreground (text) color.
+        normal (List[Tuple[int, int, int]]): A list of 8 normal intensity colors.
+        bright (List[Tuple[int, int, int]], optional): A list of 8 bright colors, or None
+            to repeat normal intensity. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        background: _ColorTuple,
+        foreground: _ColorTuple,
+        normal: List[_ColorTuple],
+        bright: Optional[List[_ColorTuple]] = None,
+    ) -> None:
+        self.background_color = ColorTriplet(*background)
+        self.foreground_color = ColorTriplet(*foreground)
+        self.ansi_colors = Palette(normal + (bright or normal))
+
+
+DEFAULT_TERMINAL_THEME = TerminalTheme(
+    (255, 255, 255),
+    (0, 0, 0),
+    [
+        (0, 0, 0),
+        (128, 0, 0),
+        (0, 128, 0),
+        (128, 128, 0),
+        (0, 0, 128),
+        (128, 0, 128),
+        (0, 128, 128),
+        (192, 192, 192),
+    ],
+    [
+        (128, 128, 128),
+        (255, 0, 0),
+        (0, 255, 0),
+        (255, 255, 0),
+        (0, 0, 255),
+        (255, 0, 255),
+        (0, 255, 255),
+        (255, 255, 255),
+    ],
+)
+
+MONOKAI = TerminalTheme(
+    (12, 12, 12),
+    (217, 217, 217),
+    [
+        (26, 26, 26),
+        (244, 0, 95),
+        (152, 224, 36),
+        (253, 151, 31),
+        (157, 101, 255),
+        (244, 0, 95),
+        (88, 209, 235),
+        (196, 197, 181),
+        (98, 94, 76),
+    ],
+    [
+        (244, 0, 95),
+        (152, 224, 36),
+        (224, 213, 97),
+        (157, 101, 255),
+        (244, 0, 95),
+        (88, 209, 235),
+        (246, 246, 239),
+    ],
+)
+DIMMED_MONOKAI = TerminalTheme(
+    (25, 25, 25),
+    (185, 188, 186),
+    [
+        (58, 61, 67),
+        (190, 63, 72),
+        (135, 154, 59),
+        (197, 166, 53),
+        (79, 118, 161),
+        (133, 92, 141),
+        (87, 143, 164),
+        (185, 188, 186),
+        (136, 137, 135),
+    ],
+    [
+        (251, 0, 31),
+        (15, 114, 47),
+        (196, 112, 51),
+        (24, 109, 227),
+        (251, 0, 103),
+        (46, 112, 109),
+        (253, 255, 185),
+    ],
+)
+NIGHT_OWLISH = TerminalTheme(
+    (255, 255, 255),
+    (64, 63, 83),
+    [
+        (1, 22, 39),
+        (211, 66, 62),
+        (42, 162, 152),
+        (218, 170, 1),
+        (72, 118, 214),
+        (64, 63, 83),
+        (8, 145, 106),
+        (122, 129, 129),
+        (122, 129, 129),
+    ],
+    [
+        (247, 110, 110),
+        (73, 208, 197),
+        (218, 194, 107),
+        (92, 167, 228),
+        (105, 112, 152),
+        (0, 201, 144),
+        (152, 159, 177),
+    ],
+)
+
+SVG_EXPORT_THEME = TerminalTheme(
+    (41, 41, 41),
+    (197, 200, 198),
+    [
+        (75, 78, 85),
+        (204, 85, 90),
+        (152, 168, 75),
+        (208, 179, 68),
+        (96, 138, 177),
+        (152, 114, 159),
+        (104, 160, 179),
+        (197, 200, 198),
+        (154, 155, 153),
+    ],
+    [
+        (255, 38, 39),
+        (0, 130, 61),
+        (208, 132, 66),
+        (25, 132, 233),
+        (255, 44, 122),
+        (57, 130, 128),
+        (253, 253, 197),
+    ],
+)

llava/lib/python3.10/site-packages/pip/_vendor/rich/text.py

@@ -0,0 +1,1361 @@
+import re
+from functools import partial, reduce
+from math import gcd
+from operator import itemgetter
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Pattern,
+    Tuple,
+    Union,
+)
+
+from ._loop import loop_last
+from ._pick import pick_bool
+from ._wrap import divide_line
+from .align import AlignMethod
+from .cells import cell_len, set_cell_size
+from .containers import Lines
+from .control import strip_control_codes
+from .emoji import EmojiVariant
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .segment import Segment
+from .style import Style, StyleType
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .console import Console, ConsoleOptions, JustifyMethod, OverflowMethod
+
+DEFAULT_JUSTIFY: "JustifyMethod" = "default"
+DEFAULT_OVERFLOW: "OverflowMethod" = "fold"
+
+
+_re_whitespace = re.compile(r"\s+$")
+
+TextType = Union[str, "Text"]
+"""A plain string or a :class:`Text` instance."""
+
+GetStyleCallable = Callable[[str], Optional[StyleType]]
+
+
+class Span(NamedTuple):
+    """A marked up region in some text."""
+
+    start: int
+    """Span start index."""
+    end: int
+    """Span end index."""
+    style: Union[str, Style]
+    """Style associated with the span."""
+
+    def __repr__(self) -> str:
+        return f"Span({self.start}, {self.end}, {self.style!r})"
+
+    def __bool__(self) -> bool:
+        return self.end > self.start
+
+    def split(self, offset: int) -> Tuple["Span", Optional["Span"]]:
+        """Split a span in to 2 from a given offset."""
+
+        if offset < self.start:
+            return self, None
+        if offset >= self.end:
+            return self, None
+
+        start, end, style = self
+        span1 = Span(start, min(end, offset), style)
+        span2 = Span(span1.end, end, style)
+        return span1, span2
+
+    def move(self, offset: int) -> "Span":
+        """Move start and end by a given offset.
+
+        Args:
+            offset (int): Number of characters to add to start and end.
+
+        Returns:
+            TextSpan: A new TextSpan with adjusted position.
+        """
+        start, end, style = self
+        return Span(start + offset, end + offset, style)
+
+    def right_crop(self, offset: int) -> "Span":
+        """Crop the span at the given offset.
+
+        Args:
+            offset (int): A value between start and end.
+
+        Returns:
+            Span: A new (possibly smaller) span.
+        """
+        start, end, style = self
+        if offset >= end:
+            return self
+        return Span(start, min(offset, end), style)
+
+    def extend(self, cells: int) -> "Span":
+        """Extend the span by the given number of cells.
+
+        Args:
+            cells (int): Additional space to add to end of span.
+
+        Returns:
+            Span: A span.
+        """
+        if cells:
+            start, end, style = self
+            return Span(start, end + cells, style)
+        else:
+            return self
+
+
+class Text(JupyterMixin):
+    """Text with color / style.
+
+    Args:
+        text (str, optional): Default unstyled text. Defaults to "".
+        style (Union[str, Style], optional): Base style for text. Defaults to "".
+        justify (str, optional): Justify method: "left", "center", "full", "right". Defaults to None.
+        overflow (str, optional): Overflow method: "crop", "fold", "ellipsis". Defaults to None.
+        no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.
+        end (str, optional): Character to end text with. Defaults to "\\\\n".
+        tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.
+        spans (List[Span], optional). A list of predefined style spans. Defaults to None.
+    """
+
+    __slots__ = [
+        "_text",
+        "style",
+        "justify",
+        "overflow",
+        "no_wrap",
+        "end",
+        "tab_size",
+        "_spans",
+        "_length",
+    ]
+
+    def __init__(
+        self,
+        text: str = "",
+        style: Union[str, Style] = "",
+        *,
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+        no_wrap: Optional[bool] = None,
+        end: str = "\n",
+        tab_size: Optional[int] = None,
+        spans: Optional[List[Span]] = None,
+    ) -> None:
+        sanitized_text = strip_control_codes(text)
+        self._text = [sanitized_text]
+        self.style = style
+        self.justify: Optional["JustifyMethod"] = justify
+        self.overflow: Optional["OverflowMethod"] = overflow
+        self.no_wrap = no_wrap
+        self.end = end
+        self.tab_size = tab_size
+        self._spans: List[Span] = spans or []
+        self._length: int = len(sanitized_text)
+
+    def __len__(self) -> int:
+        return self._length
+
+    def __bool__(self) -> bool:
+        return bool(self._length)
+
+    def __str__(self) -> str:
+        return self.plain
+
+    def __repr__(self) -> str:
+        return f"<text {self.plain!r} {self._spans!r} {self.style!r}>"
+
+    def __add__(self, other: Any) -> "Text":
+        if isinstance(other, (str, Text)):
+            result = self.copy()
+            result.append(other)
+            return result
+        return NotImplemented
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Text):
+            return NotImplemented
+        return self.plain == other.plain and self._spans == other._spans
+
+    def __contains__(self, other: object) -> bool:
+        if isinstance(other, str):
+            return other in self.plain
+        elif isinstance(other, Text):
+            return other.plain in self.plain
+        return False
+
+    def __getitem__(self, slice: Union[int, slice]) -> "Text":
+        def get_text_at(offset: int) -> "Text":
+            _Span = Span
+            text = Text(
+                self.plain[offset],
+                spans=[
+                    _Span(0, 1, style)
+                    for start, end, style in self._spans
+                    if end > offset >= start
+                ],
+                end="",
+            )
+            return text
+
+        if isinstance(slice, int):
+            return get_text_at(slice)
+        else:
+            start, stop, step = slice.indices(len(self.plain))
+            if step == 1:
+                lines = self.divide([start, stop])
+                return lines[1]
+            else:
+                # This would be a bit of work to implement efficiently
+                # For now, its not required
+                raise TypeError("slices with step!=1 are not supported")
+
+    @property
+    def cell_len(self) -> int:
+        """Get the number of cells required to render this text."""
+        return cell_len(self.plain)
+
+    @property
+    def markup(self) -> str:
+        """Get console markup to render this Text.
+
+        Returns:
+            str: A string potentially creating markup tags.
+        """
+        from .markup import escape
+
+        output: List[str] = []
+
+        plain = self.plain
+        markup_spans = [
+            (0, False, self.style),
+            *((span.start, False, span.style) for span in self._spans),
+            *((span.end, True, span.style) for span in self._spans),
+            (len(plain), True, self.style),
+        ]
+        markup_spans.sort(key=itemgetter(0, 1))
+        position = 0
+        append = output.append
+        for offset, closing, style in markup_spans:
+            if offset > position:
+                append(escape(plain[position:offset]))
+                position = offset
+            if style:
+                append(f"[/{style}]" if closing else f"[{style}]")
+        markup = "".join(output)
+        return markup
+
+    @classmethod
+    def from_markup(
+        cls,
+        text: str,
+        *,
+        style: Union[str, Style] = "",
+        emoji: bool = True,
+        emoji_variant: Optional[EmojiVariant] = None,
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+        end: str = "\n",
+    ) -> "Text":
+        """Create Text instance from markup.
+
+        Args:
+            text (str): A string containing console markup.
+            style (Union[str, Style], optional): Base style for text. Defaults to "".
+            emoji (bool, optional): Also render emoji code. Defaults to True.
+            emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.
+            justify (str, optional): Justify method: "left", "center", "full", "right". Defaults to None.
+            overflow (str, optional): Overflow method: "crop", "fold", "ellipsis". Defaults to None.
+            end (str, optional): Character to end text with. Defaults to "\\\\n".
+
+        Returns:
+            Text: A Text instance with markup rendered.
+        """
+        from .markup import render
+
+        rendered_text = render(text, style, emoji=emoji, emoji_variant=emoji_variant)
+        rendered_text.justify = justify
+        rendered_text.overflow = overflow
+        rendered_text.end = end
+        return rendered_text
+
+    @classmethod
+    def from_ansi(
+        cls,
+        text: str,
+        *,
+        style: Union[str, Style] = "",
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+        no_wrap: Optional[bool] = None,
+        end: str = "\n",
+        tab_size: Optional[int] = 8,
+    ) -> "Text":
+        """Create a Text object from a string containing ANSI escape codes.
+
+        Args:
+            text (str): A string containing escape codes.
+            style (Union[str, Style], optional): Base style for text. Defaults to "".
+            justify (str, optional): Justify method: "left", "center", "full", "right". Defaults to None.
+            overflow (str, optional): Overflow method: "crop", "fold", "ellipsis". Defaults to None.
+            no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.
+            end (str, optional): Character to end text with. Defaults to "\\\\n".
+            tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.
+        """
+        from .ansi import AnsiDecoder
+
+        joiner = Text(
+            "\n",
+            justify=justify,
+            overflow=overflow,
+            no_wrap=no_wrap,
+            end=end,
+            tab_size=tab_size,
+            style=style,
+        )
+        decoder = AnsiDecoder()
+        result = joiner.join(line for line in decoder.decode(text))
+        return result
+
+    @classmethod
+    def styled(
+        cls,
+        text: str,
+        style: StyleType = "",
+        *,
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+    ) -> "Text":
+        """Construct a Text instance with a pre-applied styled. A style applied in this way won't be used
+        to pad the text when it is justified.
+
+        Args:
+            text (str): A string containing console markup.
+            style (Union[str, Style]): Style to apply to the text. Defaults to "".
+            justify (str, optional): Justify method: "left", "center", "full", "right". Defaults to None.
+            overflow (str, optional): Overflow method: "crop", "fold", "ellipsis". Defaults to None.
+
+        Returns:
+            Text: A text instance with a style applied to the entire string.
+        """
+        styled_text = cls(text, justify=justify, overflow=overflow)
+        styled_text.stylize(style)
+        return styled_text
+
+    @classmethod
+    def assemble(
+        cls,
+        *parts: Union[str, "Text", Tuple[str, StyleType]],
+        style: Union[str, Style] = "",
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+        no_wrap: Optional[bool] = None,
+        end: str = "\n",
+        tab_size: int = 8,
+        meta: Optional[Dict[str, Any]] = None,
+    ) -> "Text":
+        """Construct a text instance by combining a sequence of strings with optional styles.
+        The positional arguments should be either strings, or a tuple of string + style.
+
+        Args:
+            style (Union[str, Style], optional): Base style for text. Defaults to "".
+            justify (str, optional): Justify method: "left", "center", "full", "right". Defaults to None.
+            overflow (str, optional): Overflow method: "crop", "fold", "ellipsis". Defaults to None.
+            no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.
+            end (str, optional): Character to end text with. Defaults to "\\\\n".
+            tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.
+            meta (Dict[str, Any], optional). Meta data to apply to text, or None for no meta data. Default to None
+
+        Returns:
+            Text: A new text instance.
+        """
+        text = cls(
+            style=style,
+            justify=justify,
+            overflow=overflow,
+            no_wrap=no_wrap,
+            end=end,
+            tab_size=tab_size,
+        )
+        append = text.append
+        _Text = Text
+        for part in parts:
+            if isinstance(part, (_Text, str)):
+                append(part)
+            else:
+                append(*part)
+        if meta:
+            text.apply_meta(meta)
+        return text
+
+    @property
+    def plain(self) -> str:
+        """Get the text as a single string."""
+        if len(self._text) != 1:
+            self._text[:] = ["".join(self._text)]
+        return self._text[0]
+
+    @plain.setter
+    def plain(self, new_text: str) -> None:
+        """Set the text to a new value."""
+        if new_text != self.plain:
+            sanitized_text = strip_control_codes(new_text)
+            self._text[:] = [sanitized_text]
+            old_length = self._length
+            self._length = len(sanitized_text)
+            if old_length > self._length:
+                self._trim_spans()
+
+    @property
+    def spans(self) -> List[Span]:
+        """Get a reference to the internal list of spans."""
+        return self._spans
+
+    @spans.setter
+    def spans(self, spans: List[Span]) -> None:
+        """Set spans."""
+        self._spans = spans[:]
+
+    def blank_copy(self, plain: str = "") -> "Text":
+        """Return a new Text instance with copied metadata (but not the string or spans)."""
+        copy_self = Text(
+            plain,
+            style=self.style,
+            justify=self.justify,
+            overflow=self.overflow,
+            no_wrap=self.no_wrap,
+            end=self.end,
+            tab_size=self.tab_size,
+        )
+        return copy_self
+
+    def copy(self) -> "Text":
+        """Return a copy of this instance."""
+        copy_self = Text(
+            self.plain,
+            style=self.style,
+            justify=self.justify,
+            overflow=self.overflow,
+            no_wrap=self.no_wrap,
+            end=self.end,
+            tab_size=self.tab_size,
+        )
+        copy_self._spans[:] = self._spans
+        return copy_self
+
+    def stylize(
+        self,
+        style: Union[str, Style],
+        start: int = 0,
+        end: Optional[int] = None,
+    ) -> None:
+        """Apply a style to the text, or a portion of the text.
+
+        Args:
+            style (Union[str, Style]): Style instance or style definition to apply.
+            start (int): Start offset (negative indexing is supported). Defaults to 0.
+            end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.
+        """
+        if style:
+            length = len(self)
+            if start < 0:
+                start = length + start
+            if end is None:
+                end = length
+            if end < 0:
+                end = length + end
+            if start >= length or end <= start:
+                # Span not in text or not valid
+                return
+            self._spans.append(Span(start, min(length, end), style))
+
+    def stylize_before(
+        self,
+        style: Union[str, Style],
+        start: int = 0,
+        end: Optional[int] = None,
+    ) -> None:
+        """Apply a style to the text, or a portion of the text. Styles will be applied before other styles already present.
+
+        Args:
+            style (Union[str, Style]): Style instance or style definition to apply.
+            start (int): Start offset (negative indexing is supported). Defaults to 0.
+            end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.
+        """
+        if style:
+            length = len(self)
+            if start < 0:
+                start = length + start
+            if end is None:
+                end = length
+            if end < 0:
+                end = length + end
+            if start >= length or end <= start:
+                # Span not in text or not valid
+                return
+            self._spans.insert(0, Span(start, min(length, end), style))
+
+    def apply_meta(
+        self, meta: Dict[str, Any], start: int = 0, end: Optional[int] = None
+    ) -> None:
+        """Apply metadata to the text, or a portion of the text.
+
+        Args:
+            meta (Dict[str, Any]): A dict of meta information.
+            start (int): Start offset (negative indexing is supported). Defaults to 0.
+            end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.
+
+        """
+        style = Style.from_meta(meta)
+        self.stylize(style, start=start, end=end)
+
+    def on(self, meta: Optional[Dict[str, Any]] = None, **handlers: Any) -> "Text":
+        """Apply event handlers (used by Textual project).
+
+        Example:
+            >>> from rich.text import Text
+            >>> text = Text("hello world")
+            >>> text.on(click="view.toggle('world')")
+
+        Args:
+            meta (Dict[str, Any]): Mapping of meta information.
+            **handlers: Keyword args are prefixed with "@" to defined handlers.
+
+        Returns:
+            Text: Self is returned to method may be chained.
+        """
+        meta = {} if meta is None else meta
+        meta.update({f"@{key}": value for key, value in handlers.items()})
+        self.stylize(Style.from_meta(meta))
+        return self
+
+    def remove_suffix(self, suffix: str) -> None:
+        """Remove a suffix if it exists.
+
+        Args:
+            suffix (str): Suffix to remove.
+        """
+        if self.plain.endswith(suffix):
+            self.right_crop(len(suffix))
+
+    def get_style_at_offset(self, console: "Console", offset: int) -> Style:
+        """Get the style of a character at give offset.
+
+        Args:
+            console (~Console): Console where text will be rendered.
+            offset (int): Offset in to text (negative indexing supported)
+
+        Returns:
+            Style: A Style instance.
+        """
+        # TODO: This is a little inefficient, it is only used by full justify
+        if offset < 0:
+            offset = len(self) + offset
+        get_style = console.get_style
+        style = get_style(self.style).copy()
+        for start, end, span_style in self._spans:
+            if end > offset >= start:
+                style += get_style(span_style, default="")
+        return style
+
+    def extend_style(self, spaces: int) -> None:
+        """Extend the Text given number of spaces where the spaces have the same style as the last character.
+
+        Args:
+            spaces (int): Number of spaces to add to the Text.
+        """
+        if spaces <= 0:
+            return
+        spans = self.spans
+        new_spaces = " " * spaces
+        if spans:
+            end_offset = len(self)
+            self._spans[:] = [
+                span.extend(spaces) if span.end >= end_offset else span
+                for span in spans
+            ]
+            self._text.append(new_spaces)
+            self._length += spaces
+        else:
+            self.plain += new_spaces
+
+    def highlight_regex(
+        self,
+        re_highlight: Union[Pattern[str], str],
+        style: Optional[Union[GetStyleCallable, StyleType]] = None,
+        *,
+        style_prefix: str = "",
+    ) -> int:
+        """Highlight text with a regular expression, where group names are
+        translated to styles.
+
+        Args:
+            re_highlight (Union[re.Pattern, str]): A regular expression object or string.
+            style (Union[GetStyleCallable, StyleType]): Optional style to apply to whole match, or a callable
+                which accepts the matched text and returns a style. Defaults to None.
+            style_prefix (str, optional): Optional prefix to add to style group names.
+
+        Returns:
+            int: Number of regex matches
+        """
+        count = 0
+        append_span = self._spans.append
+        _Span = Span
+        plain = self.plain
+        if isinstance(re_highlight, str):
+            re_highlight = re.compile(re_highlight)
+        for match in re_highlight.finditer(plain):
+            get_span = match.span
+            if style:
+                start, end = get_span()
+                match_style = style(plain[start:end]) if callable(style) else style
+                if match_style is not None and end > start:
+                    append_span(_Span(start, end, match_style))
+
+            count += 1
+            for name in match.groupdict().keys():
+                start, end = get_span(name)
+                if start != -1 and end > start:
+                    append_span(_Span(start, end, f"{style_prefix}{name}"))
+        return count
+
+    def highlight_words(
+        self,
+        words: Iterable[str],
+        style: Union[str, Style],
+        *,
+        case_sensitive: bool = True,
+    ) -> int:
+        """Highlight words with a style.
+
+        Args:
+            words (Iterable[str]): Words to highlight.
+            style (Union[str, Style]): Style to apply.
+            case_sensitive (bool, optional): Enable case sensitive matching. Defaults to True.
+
+        Returns:
+            int: Number of words highlighted.
+        """
+        re_words = "|".join(re.escape(word) for word in words)
+        add_span = self._spans.append
+        count = 0
+        _Span = Span
+        for match in re.finditer(
+            re_words, self.plain, flags=0 if case_sensitive else re.IGNORECASE
+        ):
+            start, end = match.span(0)
+            add_span(_Span(start, end, style))
+            count += 1
+        return count
+
+    def rstrip(self) -> None:
+        """Strip whitespace from end of text."""
+        self.plain = self.plain.rstrip()
+
+    def rstrip_end(self, size: int) -> None:
+        """Remove whitespace beyond a certain width at the end of the text.
+
+        Args:
+            size (int): The desired size of the text.
+        """
+        text_length = len(self)
+        if text_length > size:
+            excess = text_length - size
+            whitespace_match = _re_whitespace.search(self.plain)
+            if whitespace_match is not None:
+                whitespace_count = len(whitespace_match.group(0))
+                self.right_crop(min(whitespace_count, excess))
+
+    def set_length(self, new_length: int) -> None:
+        """Set new length of the text, clipping or padding is required."""
+        length = len(self)
+        if length != new_length:
+            if length < new_length:
+                self.pad_right(new_length - length)
+            else:
+                self.right_crop(length - new_length)
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Iterable[Segment]:
+        tab_size: int = console.tab_size if self.tab_size is None else self.tab_size
+        justify = self.justify or options.justify or DEFAULT_JUSTIFY
+
+        overflow = self.overflow or options.overflow or DEFAULT_OVERFLOW
+
+        lines = self.wrap(
+            console,
+            options.max_width,
+            justify=justify,
+            overflow=overflow,
+            tab_size=tab_size or 8,
+            no_wrap=pick_bool(self.no_wrap, options.no_wrap, False),
+        )
+        all_lines = Text("\n").join(lines)
+        yield from all_lines.render(console, end=self.end)
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Measurement:
+        text = self.plain
+        lines = text.splitlines()
+        max_text_width = max(cell_len(line) for line in lines) if lines else 0
+        words = text.split()
+        min_text_width = (
+            max(cell_len(word) for word in words) if words else max_text_width
+        )
+        return Measurement(min_text_width, max_text_width)
+
+    def render(self, console: "Console", end: str = "") -> Iterable["Segment"]:
+        """Render the text as Segments.
+
+        Args:
+            console (Console): Console instance.
+            end (Optional[str], optional): Optional end character.
+
+        Returns:
+            Iterable[Segment]: Result of render that may be written to the console.
+        """
+        _Segment = Segment
+        text = self.plain
+        if not self._spans:
+            yield Segment(text)
+            if end:
+                yield _Segment(end)
+            return
+        get_style = partial(console.get_style, default=Style.null())
+
+        enumerated_spans = list(enumerate(self._spans, 1))
+        style_map = {index: get_style(span.style) for index, span in enumerated_spans}
+        style_map[0] = get_style(self.style)
+
+        spans = [
+            (0, False, 0),
+            *((span.start, False, index) for index, span in enumerated_spans),
+            *((span.end, True, index) for index, span in enumerated_spans),
+            (len(text), True, 0),
+        ]
+        spans.sort(key=itemgetter(0, 1))
+
+        stack: List[int] = []
+        stack_append = stack.append
+        stack_pop = stack.remove
+
+        style_cache: Dict[Tuple[Style, ...], Style] = {}
+        style_cache_get = style_cache.get
+        combine = Style.combine
+
+        def get_current_style() -> Style:
+            """Construct current style from stack."""
+            styles = tuple(style_map[_style_id] for _style_id in sorted(stack))
+            cached_style = style_cache_get(styles)
+            if cached_style is not None:
+                return cached_style
+            current_style = combine(styles)
+            style_cache[styles] = current_style
+            return current_style
+
+        for (offset, leaving, style_id), (next_offset, _, _) in zip(spans, spans[1:]):
+            if leaving:
+                stack_pop(style_id)
+            else:
+                stack_append(style_id)
+            if next_offset > offset:
+                yield _Segment(text[offset:next_offset], get_current_style())
+        if end:
+            yield _Segment(end)
+
+    def join(self, lines: Iterable["Text"]) -> "Text":
+        """Join text together with this instance as the separator.
+
+        Args:
+            lines (Iterable[Text]): An iterable of Text instances to join.
+
+        Returns:
+            Text: A new text instance containing join text.
+        """
+
+        new_text = self.blank_copy()
+
+        def iter_text() -> Iterable["Text"]:
+            if self.plain:
+                for last, line in loop_last(lines):
+                    yield line
+                    if not last:
+                        yield self
+            else:
+                yield from lines
+
+        extend_text = new_text._text.extend
+        append_span = new_text._spans.append
+        extend_spans = new_text._spans.extend
+        offset = 0
+        _Span = Span
+
+        for text in iter_text():
+            extend_text(text._text)
+            if text.style:
+                append_span(_Span(offset, offset + len(text), text.style))
+            extend_spans(
+                _Span(offset + start, offset + end, style)
+                for start, end, style in text._spans
+            )
+            offset += len(text)
+        new_text._length = offset
+        return new_text
+
+    def expand_tabs(self, tab_size: Optional[int] = None) -> None:
+        """Converts tabs to spaces.
+
+        Args:
+            tab_size (int, optional): Size of tabs. Defaults to 8.
+
+        """
+        if "\t" not in self.plain:
+            return
+        if tab_size is None:
+            tab_size = self.tab_size
+        if tab_size is None:
+            tab_size = 8
+
+        new_text: List[Text] = []
+        append = new_text.append
+
+        for line in self.split("\n", include_separator=True):
+            if "\t" not in line.plain:
+                append(line)
+            else:
+                cell_position = 0
+                parts = line.split("\t", include_separator=True)
+                for part in parts:
+                    if part.plain.endswith("\t"):
+                        part._text[-1] = part._text[-1][:-1] + " "
+                        cell_position += part.cell_len
+                        tab_remainder = cell_position % tab_size
+                        if tab_remainder:
+                            spaces = tab_size - tab_remainder
+                            part.extend_style(spaces)
+                            cell_position += spaces
+                    else:
+                        cell_position += part.cell_len
+                    append(part)
+
+        result = Text("").join(new_text)
+
+        self._text = [result.plain]
+        self._length = len(self.plain)
+        self._spans[:] = result._spans
+
+    def truncate(
+        self,
+        max_width: int,
+        *,
+        overflow: Optional["OverflowMethod"] = None,
+        pad: bool = False,
+    ) -> None:
+        """Truncate text if it is longer that a given width.
+
+        Args:
+            max_width (int): Maximum number of characters in text.
+            overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to None, to use self.overflow.
+            pad (bool, optional): Pad with spaces if the length is less than max_width. Defaults to False.
+        """
+        _overflow = overflow or self.overflow or DEFAULT_OVERFLOW
+        if _overflow != "ignore":
+            length = cell_len(self.plain)
+            if length > max_width:
+                if _overflow == "ellipsis":
+                    self.plain = set_cell_size(self.plain, max_width - 1) + "…"
+                else:
+                    self.plain = set_cell_size(self.plain, max_width)
+            if pad and length < max_width:
+                spaces = max_width - length
+                self._text = [f"{self.plain}{' ' * spaces}"]
+                self._length = len(self.plain)
+
+    def _trim_spans(self) -> None:
+        """Remove or modify any spans that are over the end of the text."""
+        max_offset = len(self.plain)
+        _Span = Span
+        self._spans[:] = [
+            (
+                span
+                if span.end < max_offset
+                else _Span(span.start, min(max_offset, span.end), span.style)
+            )
+            for span in self._spans
+            if span.start < max_offset
+        ]
+
+    def pad(self, count: int, character: str = " ") -> None:
+        """Pad left and right with a given number of characters.
+
+        Args:
+            count (int): Width of padding.
+            character (str): The character to pad with. Must be a string of length 1.
+        """
+        assert len(character) == 1, "Character must be a string of length 1"
+        if count:
+            pad_characters = character * count
+            self.plain = f"{pad_characters}{self.plain}{pad_characters}"
+            _Span = Span
+            self._spans[:] = [
+                _Span(start + count, end + count, style)
+                for start, end, style in self._spans
+            ]
+
+    def pad_left(self, count: int, character: str = " ") -> None:
+        """Pad the left with a given character.
+
+        Args:
+            count (int): Number of characters to pad.
+            character (str, optional): Character to pad with. Defaults to " ".
+        """
+        assert len(character) == 1, "Character must be a string of length 1"
+        if count:
+            self.plain = f"{character * count}{self.plain}"
+            _Span = Span
+            self._spans[:] = [
+                _Span(start + count, end + count, style)
+                for start, end, style in self._spans
+            ]
+
+    def pad_right(self, count: int, character: str = " ") -> None:
+        """Pad the right with a given character.
+
+        Args:
+            count (int): Number of characters to pad.
+            character (str, optional): Character to pad with. Defaults to " ".
+        """
+        assert len(character) == 1, "Character must be a string of length 1"
+        if count:
+            self.plain = f"{self.plain}{character * count}"
+
+    def align(self, align: AlignMethod, width: int, character: str = " ") -> None:
+        """Align text to a given width.
+
+        Args:
+            align (AlignMethod): One of "left", "center", or "right".
+            width (int): Desired width.
+            character (str, optional): Character to pad with. Defaults to " ".
+        """
+        self.truncate(width)
+        excess_space = width - cell_len(self.plain)
+        if excess_space:
+            if align == "left":
+                self.pad_right(excess_space, character)
+            elif align == "center":
+                left = excess_space // 2
+                self.pad_left(left, character)
+                self.pad_right(excess_space - left, character)
+            else:
+                self.pad_left(excess_space, character)
+
+    def append(
+        self, text: Union["Text", str], style: Optional[Union[str, "Style"]] = None
+    ) -> "Text":
+        """Add text with an optional style.
+
+        Args:
+            text (Union[Text, str]): A str or Text to append.
+            style (str, optional): A style name. Defaults to None.
+
+        Returns:
+            Text: Returns self for chaining.
+        """
+
+        if not isinstance(text, (str, Text)):
+            raise TypeError("Only str or Text can be appended to Text")
+
+        if len(text):
+            if isinstance(text, str):
+                sanitized_text = strip_control_codes(text)
+                self._text.append(sanitized_text)
+                offset = len(self)
+                text_length = len(sanitized_text)
+                if style:
+                    self._spans.append(Span(offset, offset + text_length, style))
+                self._length += text_length
+            elif isinstance(text, Text):
+                _Span = Span
+                if style is not None:
+                    raise ValueError(
+                        "style must not be set when appending Text instance"
+                    )
+                text_length = self._length
+                if text.style:
+                    self._spans.append(
+                        _Span(text_length, text_length + len(text), text.style)
+                    )
+                self._text.append(text.plain)
+                self._spans.extend(
+                    _Span(start + text_length, end + text_length, style)
+                    for start, end, style in text._spans.copy()
+                )
+                self._length += len(text)
+        return self
+
+    def append_text(self, text: "Text") -> "Text":
+        """Append another Text instance. This method is more performant that Text.append, but
+        only works for Text.
+
+        Args:
+            text (Text): The Text instance to append to this instance.
+
+        Returns:
+            Text: Returns self for chaining.
+        """
+        _Span = Span
+        text_length = self._length
+        if text.style:
+            self._spans.append(_Span(text_length, text_length + len(text), text.style))
+        self._text.append(text.plain)
+        self._spans.extend(
+            _Span(start + text_length, end + text_length, style)
+            for start, end, style in text._spans.copy()
+        )
+        self._length += len(text)
+        return self
+
+    def append_tokens(
+        self, tokens: Iterable[Tuple[str, Optional[StyleType]]]
+    ) -> "Text":
+        """Append iterable of str and style. Style may be a Style instance or a str style definition.
+
+        Args:
+            tokens (Iterable[Tuple[str, Optional[StyleType]]]): An iterable of tuples containing str content and style.
+
+        Returns:
+            Text: Returns self for chaining.
+        """
+        append_text = self._text.append
+        append_span = self._spans.append
+        _Span = Span
+        offset = len(self)
+        for content, style in tokens:
+            content = strip_control_codes(content)
+            append_text(content)
+            if style:
+                append_span(_Span(offset, offset + len(content), style))
+            offset += len(content)
+        self._length = offset
+        return self
+
+    def copy_styles(self, text: "Text") -> None:
+        """Copy styles from another Text instance.
+
+        Args:
+            text (Text): A Text instance to copy styles from, must be the same length.
+        """
+        self._spans.extend(text._spans)
+
+    def split(
+        self,
+        separator: str = "\n",
+        *,
+        include_separator: bool = False,
+        allow_blank: bool = False,
+    ) -> Lines:
+        """Split rich text in to lines, preserving styles.
+
+        Args:
+            separator (str, optional): String to split on. Defaults to "\\\\n".
+            include_separator (bool, optional): Include the separator in the lines. Defaults to False.
+            allow_blank (bool, optional): Return a blank line if the text ends with a separator. Defaults to False.
+
+        Returns:
+            List[RichText]: A list of rich text, one per line of the original.
+        """
+        assert separator, "separator must not be empty"
+
+        text = self.plain
+        if separator not in text:
+            return Lines([self.copy()])
+
+        if include_separator:
+            lines = self.divide(
+                match.end() for match in re.finditer(re.escape(separator), text)
+            )
+        else:
+
+            def flatten_spans() -> Iterable[int]:
+                for match in re.finditer(re.escape(separator), text):
+                    start, end = match.span()
+                    yield start
+                    yield end
+
+            lines = Lines(
+                line for line in self.divide(flatten_spans()) if line.plain != separator
+            )
+
+        if not allow_blank and text.endswith(separator):
+            lines.pop()
+
+        return lines
+
+    def divide(self, offsets: Iterable[int]) -> Lines:
+        """Divide text in to a number of lines at given offsets.
+
+        Args:
+            offsets (Iterable[int]): Offsets used to divide text.
+
+        Returns:
+            Lines: New RichText instances between offsets.
+        """
+        _offsets = list(offsets)
+
+        if not _offsets:
+            return Lines([self.copy()])
+
+        text = self.plain
+        text_length = len(text)
+        divide_offsets = [0, *_offsets, text_length]
+        line_ranges = list(zip(divide_offsets, divide_offsets[1:]))
+
+        style = self.style
+        justify = self.justify
+        overflow = self.overflow
+        _Text = Text
+        new_lines = Lines(
+            _Text(
+                text[start:end],
+                style=style,
+                justify=justify,
+                overflow=overflow,
+            )
+            for start, end in line_ranges
+        )
+        if not self._spans:
+            return new_lines
+
+        _line_appends = [line._spans.append for line in new_lines._lines]
+        line_count = len(line_ranges)
+        _Span = Span
+
+        for span_start, span_end, style in self._spans:
+            lower_bound = 0
+            upper_bound = line_count
+            start_line_no = (lower_bound + upper_bound) // 2
+
+            while True:
+                line_start, line_end = line_ranges[start_line_no]
+                if span_start < line_start:
+                    upper_bound = start_line_no - 1
+                elif span_start > line_end:
+                    lower_bound = start_line_no + 1
+                else:
+                    break
+                start_line_no = (lower_bound + upper_bound) // 2
+
+            if span_end < line_end:
+                end_line_no = start_line_no
+            else:
+                end_line_no = lower_bound = start_line_no
+                upper_bound = line_count
+
+                while True:
+                    line_start, line_end = line_ranges[end_line_no]
+                    if span_end < line_start:
+                        upper_bound = end_line_no - 1
+                    elif span_end > line_end:
+                        lower_bound = end_line_no + 1
+                    else:
+                        break
+                    end_line_no = (lower_bound + upper_bound) // 2
+
+            for line_no in range(start_line_no, end_line_no + 1):
+                line_start, line_end = line_ranges[line_no]
+                new_start = max(0, span_start - line_start)
+                new_end = min(span_end - line_start, line_end - line_start)
+                if new_end > new_start:
+                    _line_appends[line_no](_Span(new_start, new_end, style))
+
+        return new_lines
+
+    def right_crop(self, amount: int = 1) -> None:
+        """Remove a number of characters from the end of the text."""
+        max_offset = len(self.plain) - amount
+        _Span = Span
+        self._spans[:] = [
+            (
+                span
+                if span.end < max_offset
+                else _Span(span.start, min(max_offset, span.end), span.style)
+            )
+            for span in self._spans
+            if span.start < max_offset
+        ]
+        self._text = [self.plain[:-amount]]
+        self._length -= amount
+
+    def wrap(
+        self,
+        console: "Console",
+        width: int,
+        *,
+        justify: Optional["JustifyMethod"] = None,
+        overflow: Optional["OverflowMethod"] = None,
+        tab_size: int = 8,
+        no_wrap: Optional[bool] = None,
+    ) -> Lines:
+        """Word wrap the text.
+
+        Args:
+            console (Console): Console instance.
+            width (int): Number of cells available per line.
+            justify (str, optional): Justify method: "default", "left", "center", "full", "right". Defaults to "default".
+            overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to None.
+            tab_size (int, optional): Default tab size. Defaults to 8.
+            no_wrap (bool, optional): Disable wrapping, Defaults to False.
+
+        Returns:
+            Lines: Number of lines.
+        """
+        wrap_justify = justify or self.justify or DEFAULT_JUSTIFY
+        wrap_overflow = overflow or self.overflow or DEFAULT_OVERFLOW
+
+        no_wrap = pick_bool(no_wrap, self.no_wrap, False) or overflow == "ignore"
+
+        lines = Lines()
+        for line in self.split(allow_blank=True):
+            if "\t" in line:
+                line.expand_tabs(tab_size)
+            if no_wrap:
+                new_lines = Lines([line])
+            else:
+                offsets = divide_line(str(line), width, fold=wrap_overflow == "fold")
+                new_lines = line.divide(offsets)
+            for line in new_lines:
+                line.rstrip_end(width)
+            if wrap_justify:
+                new_lines.justify(
+                    console, width, justify=wrap_justify, overflow=wrap_overflow
+                )
+            for line in new_lines:
+                line.truncate(width, overflow=wrap_overflow)
+            lines.extend(new_lines)
+        return lines
+
+    def fit(self, width: int) -> Lines:
+        """Fit the text in to given width by chopping in to lines.
+
+        Args:
+            width (int): Maximum characters in a line.
+
+        Returns:
+            Lines: Lines container.
+        """
+        lines: Lines = Lines()
+        append = lines.append
+        for line in self.split():
+            line.set_length(width)
+            append(line)
+        return lines
+
+    def detect_indentation(self) -> int:
+        """Auto-detect indentation of code.
+
+        Returns:
+            int: Number of spaces used to indent code.
+        """
+
+        _indentations = {
+            len(match.group(1))
+            for match in re.finditer(r"^( *)(.*)$", self.plain, flags=re.MULTILINE)
+        }
+
+        try:
+            indentation = (
+                reduce(gcd, [indent for indent in _indentations if not indent % 2]) or 1
+            )
+        except TypeError:
+            indentation = 1
+
+        return indentation
+
+    def with_indent_guides(
+        self,
+        indent_size: Optional[int] = None,
+        *,
+        character: str = "│",
+        style: StyleType = "dim green",
+    ) -> "Text":
+        """Adds indent guide lines to text.
+
+        Args:
+            indent_size (Optional[int]): Size of indentation, or None to auto detect. Defaults to None.
+            character (str, optional): Character to use for indentation. Defaults to "│".
+            style (Union[Style, str], optional): Style of indent guides.
+
+        Returns:
+            Text: New text with indentation guides.
+        """
+
+        _indent_size = self.detect_indentation() if indent_size is None else indent_size
+
+        text = self.copy()
+        text.expand_tabs()
+        indent_line = f"{character}{' ' * (_indent_size - 1)}"
+
+        re_indent = re.compile(r"^( *)(.*)$")
+        new_lines: List[Text] = []
+        add_line = new_lines.append
+        blank_lines = 0
+        for line in text.split(allow_blank=True):
+            match = re_indent.match(line.plain)
+            if not match or not match.group(2):
+                blank_lines += 1
+                continue
+            indent = match.group(1)
+            full_indents, remaining_space = divmod(len(indent), _indent_size)
+            new_indent = f"{indent_line * full_indents}{' ' * remaining_space}"
+            line.plain = new_indent + line.plain[len(new_indent) :]
+            line.stylize(style, 0, len(new_indent))
+            if blank_lines:
+                new_lines.extend([Text(new_indent, style=style)] * blank_lines)
+                blank_lines = 0
+            add_line(line)
+        if blank_lines:
+            new_lines.extend([Text("", style=style)] * blank_lines)
+
+        new_text = text.blank_copy("\n").join(new_lines)
+        return new_text
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.console import Console
+
+    text = Text(
+        """\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n"""
+    )
+    text.highlight_words(["Lorem"], "bold")
+    text.highlight_words(["ipsum"], "italic")
+
+    console = Console()
+
+    console.rule("justify='left'")
+    console.print(text, style="red")
+    console.print()
+
+    console.rule("justify='center'")
+    console.print(text, style="green", justify="center")
+    console.print()
+
+    console.rule("justify='right'")
+    console.print(text, style="blue", justify="right")
+    console.print()
+
+    console.rule("justify='full'")
+    console.print(text, style="magenta", justify="full")
+    console.print()

llava/lib/python3.10/site-packages/pip/_vendor/rich/theme.py

@@ -0,0 +1,115 @@
+import configparser
+from typing import IO, Dict, List, Mapping, Optional
+
+from .default_styles import DEFAULT_STYLES
+from .style import Style, StyleType
+
+
+class Theme:
+    """A container for style information, used by :class:`~rich.console.Console`.
+
+    Args:
+        styles (Dict[str, Style], optional): A mapping of style names on to styles. Defaults to None for a theme with no styles.
+        inherit (bool, optional): Inherit default styles. Defaults to True.
+    """
+
+    styles: Dict[str, Style]
+
+    def __init__(
+        self, styles: Optional[Mapping[str, StyleType]] = None, inherit: bool = True
+    ):
+        self.styles = DEFAULT_STYLES.copy() if inherit else {}
+        if styles is not None:
+            self.styles.update(
+                {
+                    name: style if isinstance(style, Style) else Style.parse(style)
+                    for name, style in styles.items()
+                }
+            )
+
+    @property
+    def config(self) -> str:
+        """Get contents of a config file for this theme."""
+        config = "[styles]\n" + "\n".join(
+            f"{name} = {style}" for name, style in sorted(self.styles.items())
+        )
+        return config
+
+    @classmethod
+    def from_file(
+        cls, config_file: IO[str], source: Optional[str] = None, inherit: bool = True
+    ) -> "Theme":
+        """Load a theme from a text mode file.
+
+        Args:
+            config_file (IO[str]): An open conf file.
+            source (str, optional): The filename of the open file. Defaults to None.
+            inherit (bool, optional): Inherit default styles. Defaults to True.
+
+        Returns:
+            Theme: A New theme instance.
+        """
+        config = configparser.ConfigParser()
+        config.read_file(config_file, source=source)
+        styles = {name: Style.parse(value) for name, value in config.items("styles")}
+        theme = Theme(styles, inherit=inherit)
+        return theme
+
+    @classmethod
+    def read(
+        cls, path: str, inherit: bool = True, encoding: Optional[str] = None
+    ) -> "Theme":
+        """Read a theme from a path.
+
+        Args:
+            path (str): Path to a config file readable by Python configparser module.
+            inherit (bool, optional): Inherit default styles. Defaults to True.
+            encoding (str, optional): Encoding of the config file. Defaults to None.
+
+        Returns:
+            Theme: A new theme instance.
+        """
+        with open(path, encoding=encoding) as config_file:
+            return cls.from_file(config_file, source=path, inherit=inherit)
+
+
+class ThemeStackError(Exception):
+    """Base exception for errors related to the theme stack."""
+
+
+class ThemeStack:
+    """A stack of themes.
+
+    Args:
+        theme (Theme): A theme instance
+    """
+
+    def __init__(self, theme: Theme) -> None:
+        self._entries: List[Dict[str, Style]] = [theme.styles]
+        self.get = self._entries[-1].get
+
+    def push_theme(self, theme: Theme, inherit: bool = True) -> None:
+        """Push a theme on the top of the stack.
+
+        Args:
+            theme (Theme): A Theme instance.
+            inherit (boolean, optional): Inherit styles from current top of stack.
+        """
+        styles: Dict[str, Style]
+        styles = (
+            {**self._entries[-1], **theme.styles} if inherit else theme.styles.copy()
+        )
+        self._entries.append(styles)
+        self.get = self._entries[-1].get
+
+    def pop_theme(self) -> None:
+        """Pop (and discard) the top-most theme."""
+        if len(self._entries) == 1:
+            raise ThemeStackError("Unable to pop base theme")
+        self._entries.pop()
+        self.get = self._entries[-1].get
+
+
+if __name__ == "__main__":  # pragma: no cover
+    theme = Theme()
+    print(theme.config)

llava/lib/python3.10/site-packages/pip/_vendor/rich/traceback.py

@@ -0,0 +1,797 @@
+import inspect
+import linecache
+import os
+import sys
+from dataclasses import dataclass, field
+from itertools import islice
+from traceback import walk_tb
+from types import ModuleType, TracebackType
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
+
+from pip._vendor.pygments.lexers import guess_lexer_for_filename
+from pip._vendor.pygments.token import Comment, Keyword, Name, Number, Operator, String
+from pip._vendor.pygments.token import Text as TextToken
+from pip._vendor.pygments.token import Token
+from pip._vendor.pygments.util import ClassNotFound
+
+from . import pretty
+from ._loop import loop_last
+from .columns import Columns
+from .console import Console, ConsoleOptions, ConsoleRenderable, RenderResult, group
+from .constrain import Constrain
+from .highlighter import RegexHighlighter, ReprHighlighter
+from .panel import Panel
+from .scope import render_scope
+from .style import Style
+from .syntax import Syntax
+from .text import Text
+from .theme import Theme
+
+WINDOWS = sys.platform == "win32"
+
+LOCALS_MAX_LENGTH = 10
+LOCALS_MAX_STRING = 80
+
+
+def install(
+    *,
+    console: Optional[Console] = None,
+    width: Optional[int] = 100,
+    code_width: Optional[int] = 88,
+    extra_lines: int = 3,
+    theme: Optional[str] = None,
+    word_wrap: bool = False,
+    show_locals: bool = False,
+    locals_max_length: int = LOCALS_MAX_LENGTH,
+    locals_max_string: int = LOCALS_MAX_STRING,
+    locals_hide_dunder: bool = True,
+    locals_hide_sunder: Optional[bool] = None,
+    indent_guides: bool = True,
+    suppress: Iterable[Union[str, ModuleType]] = (),
+    max_frames: int = 100,
+) -> Callable[[Type[BaseException], BaseException, Optional[TracebackType]], Any]:
+    """Install a rich traceback handler.
+
+    Once installed, any tracebacks will be printed with syntax highlighting and rich formatting.
+
+
+    Args:
+        console (Optional[Console], optional): Console to write exception to. Default uses internal Console instance.
+        width (Optional[int], optional): Width (in characters) of traceback. Defaults to 100.
+        code_width (Optional[int], optional): Code width (in characters) of traceback. Defaults to 88.
+        extra_lines (int, optional): Extra lines of code. Defaults to 3.
+        theme (Optional[str], optional): Pygments theme to use in traceback. Defaults to ``None`` which will pick
+            a theme appropriate for the platform.
+        word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.
+        show_locals (bool, optional): Enable display of local variables. Defaults to False.
+        locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
+            Defaults to 10.
+        locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.
+        locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.
+        locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.
+        indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.
+        suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
+
+    Returns:
+        Callable: The previous exception handler that was replaced.
+
+    """
+    traceback_console = Console(stderr=True) if console is None else console
+
+    locals_hide_sunder = (
+        True
+        if (traceback_console.is_jupyter and locals_hide_sunder is None)
+        else locals_hide_sunder
+    )
+
+    def excepthook(
+        type_: Type[BaseException],
+        value: BaseException,
+        traceback: Optional[TracebackType],
+    ) -> None:
+        traceback_console.print(
+            Traceback.from_exception(
+                type_,
+                value,
+                traceback,
+                width=width,
+                code_width=code_width,
+                extra_lines=extra_lines,
+                theme=theme,
+                word_wrap=word_wrap,
+                show_locals=show_locals,
+                locals_max_length=locals_max_length,
+                locals_max_string=locals_max_string,
+                locals_hide_dunder=locals_hide_dunder,
+                locals_hide_sunder=bool(locals_hide_sunder),
+                indent_guides=indent_guides,
+                suppress=suppress,
+                max_frames=max_frames,
+            )
+        )
+
+    def ipy_excepthook_closure(ip: Any) -> None:  # pragma: no cover
+        tb_data = {}  # store information about showtraceback call
+        default_showtraceback = ip.showtraceback  # keep reference of default traceback
+
+        def ipy_show_traceback(*args: Any, **kwargs: Any) -> None:
+            """wrap the default ip.showtraceback to store info for ip._showtraceback"""
+            nonlocal tb_data
+            tb_data = kwargs
+            default_showtraceback(*args, **kwargs)
+
+        def ipy_display_traceback(
+            *args: Any, is_syntax: bool = False, **kwargs: Any
+        ) -> None:
+            """Internally called traceback from ip._showtraceback"""
+            nonlocal tb_data
+            exc_tuple = ip._get_exc_info()
+
+            # do not display trace on syntax error
+            tb: Optional[TracebackType] = None if is_syntax else exc_tuple[2]
+
+            # determine correct tb_offset
+            compiled = tb_data.get("running_compiled_code", False)
+            tb_offset = tb_data.get("tb_offset", 1 if compiled else 0)
+            # remove ipython internal frames from trace with tb_offset
+            for _ in range(tb_offset):
+                if tb is None:
+                    break
+                tb = tb.tb_next
+
+            excepthook(exc_tuple[0], exc_tuple[1], tb)
+            tb_data = {}  # clear data upon usage
+
+        # replace _showtraceback instead of showtraceback to allow ipython features such as debugging to work
+        # this is also what the ipython docs recommends to modify when subclassing InteractiveShell
+        ip._showtraceback = ipy_display_traceback
+        # add wrapper to capture tb_data
+        ip.showtraceback = ipy_show_traceback
+        ip.showsyntaxerror = lambda *args, **kwargs: ipy_display_traceback(
+            *args, is_syntax=True, **kwargs
+        )
+
+    try:  # pragma: no cover
+        # if within ipython, use customized traceback
+        ip = get_ipython()  # type: ignore[name-defined]
+        ipy_excepthook_closure(ip)
+        return sys.excepthook
+    except Exception:
+        # otherwise use default system hook
+        old_excepthook = sys.excepthook
+        sys.excepthook = excepthook
+        return old_excepthook
+
+
+@dataclass
+class Frame:
+    filename: str
+    lineno: int
+    name: str
+    line: str = ""
+    locals: Optional[Dict[str, pretty.Node]] = None
+    last_instruction: Optional[Tuple[Tuple[int, int], Tuple[int, int]]] = None
+
+
+@dataclass
+class _SyntaxError:
+    offset: int
+    filename: str
+    line: str
+    lineno: int
+    msg: str
+
+
+@dataclass
+class Stack:
+    exc_type: str
+    exc_value: str
+    syntax_error: Optional[_SyntaxError] = None
+    is_cause: bool = False
+    frames: List[Frame] = field(default_factory=list)
+
+
+@dataclass
+class Trace:
+    stacks: List[Stack]
+
+
+class PathHighlighter(RegexHighlighter):
+    highlights = [r"(?P<dim>.*/)(?P<bold>.+)"]
+
+
+class Traceback:
+    """A Console renderable that renders a traceback.
+
+    Args:
+        trace (Trace, optional): A `Trace` object produced from `extract`. Defaults to None, which uses
+            the last exception.
+        width (Optional[int], optional): Number of characters used to traceback. Defaults to 100.
+        code_width (Optional[int], optional): Number of code characters used to traceback. Defaults to 88.
+        extra_lines (int, optional): Additional lines of code to render. Defaults to 3.
+        theme (str, optional): Override pygments theme used in traceback.
+        word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.
+        show_locals (bool, optional): Enable display of local variables. Defaults to False.
+        indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.
+        locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
+            Defaults to 10.
+        locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.
+        locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.
+        locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.
+        suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
+        max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.
+
+    """
+
+    LEXERS = {
+        "": "text",
+        ".py": "python",
+        ".pxd": "cython",
+        ".pyx": "cython",
+        ".pxi": "pyrex",
+    }
+
+    def __init__(
+        self,
+        trace: Optional[Trace] = None,
+        *,
+        width: Optional[int] = 100,
+        code_width: Optional[int] = 88,
+        extra_lines: int = 3,
+        theme: Optional[str] = None,
+        word_wrap: bool = False,
+        show_locals: bool = False,
+        locals_max_length: int = LOCALS_MAX_LENGTH,
+        locals_max_string: int = LOCALS_MAX_STRING,
+        locals_hide_dunder: bool = True,
+        locals_hide_sunder: bool = False,
+        indent_guides: bool = True,
+        suppress: Iterable[Union[str, ModuleType]] = (),
+        max_frames: int = 100,
+    ):
+        if trace is None:
+            exc_type, exc_value, traceback = sys.exc_info()
+            if exc_type is None or exc_value is None or traceback is None:
+                raise ValueError(
+                    "Value for 'trace' required if not called in except: block"
+                )
+            trace = self.extract(
+                exc_type, exc_value, traceback, show_locals=show_locals
+            )
+        self.trace = trace
+        self.width = width
+        self.code_width = code_width
+        self.extra_lines = extra_lines
+        self.theme = Syntax.get_theme(theme or "ansi_dark")
+        self.word_wrap = word_wrap
+        self.show_locals = show_locals
+        self.indent_guides = indent_guides
+        self.locals_max_length = locals_max_length
+        self.locals_max_string = locals_max_string
+        self.locals_hide_dunder = locals_hide_dunder
+        self.locals_hide_sunder = locals_hide_sunder
+
+        self.suppress: Sequence[str] = []
+        for suppress_entity in suppress:
+            if not isinstance(suppress_entity, str):
+                assert (
+                    suppress_entity.__file__ is not None
+                ), f"{suppress_entity!r} must be a module with '__file__' attribute"
+                path = os.path.dirname(suppress_entity.__file__)
+            else:
+                path = suppress_entity
+            path = os.path.normpath(os.path.abspath(path))
+            self.suppress.append(path)
+        self.max_frames = max(4, max_frames) if max_frames > 0 else 0
+
+    @classmethod
+    def from_exception(
+        cls,
+        exc_type: Type[Any],
+        exc_value: BaseException,
+        traceback: Optional[TracebackType],
+        *,
+        width: Optional[int] = 100,
+        code_width: Optional[int] = 88,
+        extra_lines: int = 3,
+        theme: Optional[str] = None,
+        word_wrap: bool = False,
+        show_locals: bool = False,
+        locals_max_length: int = LOCALS_MAX_LENGTH,
+        locals_max_string: int = LOCALS_MAX_STRING,
+        locals_hide_dunder: bool = True,
+        locals_hide_sunder: bool = False,
+        indent_guides: bool = True,
+        suppress: Iterable[Union[str, ModuleType]] = (),
+        max_frames: int = 100,
+    ) -> "Traceback":
+        """Create a traceback from exception info
+
+        Args:
+            exc_type (Type[BaseException]): Exception type.
+            exc_value (BaseException): Exception value.
+            traceback (TracebackType): Python Traceback object.
+            width (Optional[int], optional): Number of characters used to traceback. Defaults to 100.
+            code_width (Optional[int], optional): Number of code characters used to traceback. Defaults to 88.
+            extra_lines (int, optional): Additional lines of code to render. Defaults to 3.
+            theme (str, optional): Override pygments theme used in traceback.
+            word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.
+            show_locals (bool, optional): Enable display of local variables. Defaults to False.
+            indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.
+            locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
+                Defaults to 10.
+            locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.
+            locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.
+            locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.
+            suppress (Iterable[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
+            max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.
+
+        Returns:
+            Traceback: A Traceback instance that may be printed.
+        """
+        rich_traceback = cls.extract(
+            exc_type,
+            exc_value,
+            traceback,
+            show_locals=show_locals,
+            locals_max_length=locals_max_length,
+            locals_max_string=locals_max_string,
+            locals_hide_dunder=locals_hide_dunder,
+            locals_hide_sunder=locals_hide_sunder,
+        )
+
+        return cls(
+            rich_traceback,
+            width=width,
+            code_width=code_width,
+            extra_lines=extra_lines,
+            theme=theme,
+            word_wrap=word_wrap,
+            show_locals=show_locals,
+            indent_guides=indent_guides,
+            locals_max_length=locals_max_length,
+            locals_max_string=locals_max_string,
+            locals_hide_dunder=locals_hide_dunder,
+            locals_hide_sunder=locals_hide_sunder,
+            suppress=suppress,
+            max_frames=max_frames,
+        )
+
+    @classmethod
+    def extract(
+        cls,
+        exc_type: Type[BaseException],
+        exc_value: BaseException,
+        traceback: Optional[TracebackType],
+        *,
+        show_locals: bool = False,
+        locals_max_length: int = LOCALS_MAX_LENGTH,
+        locals_max_string: int = LOCALS_MAX_STRING,
+        locals_hide_dunder: bool = True,
+        locals_hide_sunder: bool = False,
+    ) -> Trace:
+        """Extract traceback information.
+
+        Args:
+            exc_type (Type[BaseException]): Exception type.
+            exc_value (BaseException): Exception value.
+            traceback (TracebackType): Python Traceback object.
+            show_locals (bool, optional): Enable display of local variables. Defaults to False.
+            locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
+                Defaults to 10.
+            locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.
+            locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.
+            locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.
+
+        Returns:
+            Trace: A Trace instance which you can use to construct a `Traceback`.
+        """
+
+        stacks: List[Stack] = []
+        is_cause = False
+
+        from pip._vendor.rich import _IMPORT_CWD
+
+        def safe_str(_object: Any) -> str:
+            """Don't allow exceptions from __str__ to propagate."""
+            try:
+                return str(_object)
+            except Exception:
+                return "<exception str() failed>"
+
+        while True:
+            stack = Stack(
+                exc_type=safe_str(exc_type.__name__),
+                exc_value=safe_str(exc_value),
+                is_cause=is_cause,
+            )
+
+            if isinstance(exc_value, SyntaxError):
+                stack.syntax_error = _SyntaxError(
+                    offset=exc_value.offset or 0,
+                    filename=exc_value.filename or "?",
+                    lineno=exc_value.lineno or 0,
+                    line=exc_value.text or "",
+                    msg=exc_value.msg,
+                )
+
+            stacks.append(stack)
+            append = stack.frames.append
+
+            def get_locals(
+                iter_locals: Iterable[Tuple[str, object]]
+            ) -> Iterable[Tuple[str, object]]:
+                """Extract locals from an iterator of key pairs."""
+                if not (locals_hide_dunder or locals_hide_sunder):
+                    yield from iter_locals
+                    return
+                for key, value in iter_locals:
+                    if locals_hide_dunder and key.startswith("__"):
+                        continue
+                    if locals_hide_sunder and key.startswith("_"):
+                        continue
+                    yield key, value
+
+            for frame_summary, line_no in walk_tb(traceback):
+                filename = frame_summary.f_code.co_filename
+
+                last_instruction: Optional[Tuple[Tuple[int, int], Tuple[int, int]]]
+                last_instruction = None
+                if sys.version_info >= (3, 11):
+                    instruction_index = frame_summary.f_lasti // 2
+                    instruction_position = next(
+                        islice(
+                            frame_summary.f_code.co_positions(),
+                            instruction_index,
+                            instruction_index + 1,
+                        )
+                    )
+                    (
+                        start_line,
+                        end_line,
+                        start_column,
+                        end_column,
+                    ) = instruction_position
+                    if (
+                        start_line is not None
+                        and end_line is not None
+                        and start_column is not None
+                        and end_column is not None
+                    ):
+                        last_instruction = (
+                            (start_line, start_column),
+                            (end_line, end_column),
+                        )
+
+                if filename and not filename.startswith("<"):
+                    if not os.path.isabs(filename):
+                        filename = os.path.join(_IMPORT_CWD, filename)
+                if frame_summary.f_locals.get("_rich_traceback_omit", False):
+                    continue
+
+                frame = Frame(
+                    filename=filename or "?",
+                    lineno=line_no,
+                    name=frame_summary.f_code.co_name,
+                    locals=(
+                        {
+                            key: pretty.traverse(
+                                value,
+                                max_length=locals_max_length,
+                                max_string=locals_max_string,
+                            )
+                            for key, value in get_locals(frame_summary.f_locals.items())
+                            if not (inspect.isfunction(value) or inspect.isclass(value))
+                        }
+                        if show_locals
+                        else None
+                    ),
+                    last_instruction=last_instruction,
+                )
+                append(frame)
+                if frame_summary.f_locals.get("_rich_traceback_guard", False):
+                    del stack.frames[:]
+
+            cause = getattr(exc_value, "__cause__", None)
+            if cause:
+                exc_type = cause.__class__
+                exc_value = cause
+                # __traceback__ can be None, e.g. for exceptions raised by the
+                # 'multiprocessing' module
+                traceback = cause.__traceback__
+                is_cause = True
+                continue
+
+            cause = exc_value.__context__
+            if cause and not getattr(exc_value, "__suppress_context__", False):
+                exc_type = cause.__class__
+                exc_value = cause
+                traceback = cause.__traceback__
+                is_cause = False
+                continue
+            # No cover, code is reached but coverage doesn't recognize it.
+            break  # pragma: no cover
+
+        trace = Trace(stacks=stacks)
+        return trace
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        theme = self.theme
+        background_style = theme.get_background_style()
+        token_style = theme.get_style_for_token
+
+        traceback_theme = Theme(
+            {
+                "pretty": token_style(TextToken),
+                "pygments.text": token_style(Token),
+                "pygments.string": token_style(String),
+                "pygments.function": token_style(Name.Function),
+                "pygments.number": token_style(Number),
+                "repr.indent": token_style(Comment) + Style(dim=True),
+                "repr.str": token_style(String),
+                "repr.brace": token_style(TextToken) + Style(bold=True),
+                "repr.number": token_style(Number),
+                "repr.bool_true": token_style(Keyword.Constant),
+                "repr.bool_false": token_style(Keyword.Constant),
+                "repr.none": token_style(Keyword.Constant),
+                "scope.border": token_style(String.Delimiter),
+                "scope.equals": token_style(Operator),
+                "scope.key": token_style(Name),
+                "scope.key.special": token_style(Name.Constant) + Style(dim=True),
+            },
+            inherit=False,
+        )
+
+        highlighter = ReprHighlighter()
+        for last, stack in loop_last(reversed(self.trace.stacks)):
+            if stack.frames:
+                stack_renderable: ConsoleRenderable = Panel(
+                    self._render_stack(stack),
+                    title="[traceback.title]Traceback [dim](most recent call last)",
+                    style=background_style,
+                    border_style="traceback.border",
+                    expand=True,
+                    padding=(0, 1),
+                )
+                stack_renderable = Constrain(stack_renderable, self.width)
+                with console.use_theme(traceback_theme):
+                    yield stack_renderable
+            if stack.syntax_error is not None:
+                with console.use_theme(traceback_theme):
+                    yield Constrain(
+                        Panel(
+                            self._render_syntax_error(stack.syntax_error),
+                            style=background_style,
+                            border_style="traceback.border.syntax_error",
+                            expand=True,
+                            padding=(0, 1),
+                            width=self.width,
+                        ),
+                        self.width,
+                    )
+                yield Text.assemble(
+                    (f"{stack.exc_type}: ", "traceback.exc_type"),
+                    highlighter(stack.syntax_error.msg),
+                )
+            elif stack.exc_value:
+                yield Text.assemble(
+                    (f"{stack.exc_type}: ", "traceback.exc_type"),
+                    highlighter(stack.exc_value),
+                )
+            else:
+                yield Text.assemble((f"{stack.exc_type}", "traceback.exc_type"))
+
+            if not last:
+                if stack.is_cause:
+                    yield Text.from_markup(
+                        "\n[i]The above exception was the direct cause of the following exception:\n",
+                    )
+                else:
+                    yield Text.from_markup(
+                        "\n[i]During handling of the above exception, another exception occurred:\n",
+                    )
+
+    @group()
+    def _render_syntax_error(self, syntax_error: _SyntaxError) -> RenderResult:
+        highlighter = ReprHighlighter()
+        path_highlighter = PathHighlighter()
+        if syntax_error.filename != "<stdin>":
+            if os.path.exists(syntax_error.filename):
+                text = Text.assemble(
+                    (f" {syntax_error.filename}", "pygments.string"),
+                    (":", "pygments.text"),
+                    (str(syntax_error.lineno), "pygments.number"),
+                    style="pygments.text",
+                )
+                yield path_highlighter(text)
+        syntax_error_text = highlighter(syntax_error.line.rstrip())
+        syntax_error_text.no_wrap = True
+        offset = min(syntax_error.offset - 1, len(syntax_error_text))
+        syntax_error_text.stylize("bold underline", offset, offset)
+        syntax_error_text += Text.from_markup(
+            "\n" + " " * offset + "[traceback.offset]▲[/]",
+            style="pygments.text",
+        )
+        yield syntax_error_text
+
+    @classmethod
+    def _guess_lexer(cls, filename: str, code: str) -> str:
+        ext = os.path.splitext(filename)[-1]
+        if not ext:
+            # No extension, look at first line to see if it is a hashbang
+            # Note, this is an educated guess and not a guarantee
+            # If it fails, the only downside is that the code is highlighted strangely
+            new_line_index = code.index("\n")
+            first_line = code[:new_line_index] if new_line_index != -1 else code
+            if first_line.startswith("#!") and "python" in first_line.lower():
+                return "python"
+        try:
+            return cls.LEXERS.get(ext) or guess_lexer_for_filename(filename, code).name
+        except ClassNotFound:
+            return "text"
+
+    @group()
+    def _render_stack(self, stack: Stack) -> RenderResult:
+        path_highlighter = PathHighlighter()
+        theme = self.theme
+
+        def read_code(filename: str) -> str:
+            """Read files, and cache results on filename.
+
+            Args:
+                filename (str): Filename to read
+
+            Returns:
+                str: Contents of file
+            """
+            return "".join(linecache.getlines(filename))
+
+        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
+            if frame.locals:
+                yield render_scope(
+                    frame.locals,
+                    title="locals",
+                    indent_guides=self.indent_guides,
+                    max_length=self.locals_max_length,
+                    max_string=self.locals_max_string,
+                )
+
+        exclude_frames: Optional[range] = None
+        if self.max_frames != 0:
+            exclude_frames = range(
+                self.max_frames // 2,
+                len(stack.frames) - self.max_frames // 2,
+            )
+
+        excluded = False
+        for frame_index, frame in enumerate(stack.frames):
+            if exclude_frames and frame_index in exclude_frames:
+                excluded = True
+                continue
+
+            if excluded:
+                assert exclude_frames is not None
+                yield Text(
+                    f"\n... {len(exclude_frames)} frames hidden ...",
+                    justify="center",
+                    style="traceback.error",
+                )
+                excluded = False
+
+            first = frame_index == 0
+            frame_filename = frame.filename
+            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
+
+            if os.path.exists(frame.filename):
+                text = Text.assemble(
+                    path_highlighter(Text(frame.filename, style="pygments.string")),
+                    (":", "pygments.text"),
+                    (str(frame.lineno), "pygments.number"),
+                    " in ",
+                    (frame.name, "pygments.function"),
+                    style="pygments.text",
+                )
+            else:
+                text = Text.assemble(
+                    "in ",
+                    (frame.name, "pygments.function"),
+                    (":", "pygments.text"),
+                    (str(frame.lineno), "pygments.number"),
+                    style="pygments.text",
+                )
+            if not frame.filename.startswith("<") and not first:
+                yield ""
+            yield text
+            if frame.filename.startswith("<"):
+                yield from render_locals(frame)
+                continue
+            if not suppressed:
+                try:
+                    code = read_code(frame.filename)
+                    if not code:
+                        # code may be an empty string if the file doesn't exist, OR
+                        # if the traceback filename is generated dynamically
+                        continue
+                    lexer_name = self._guess_lexer(frame.filename, code)
+                    syntax = Syntax(
+                        code,
+                        lexer_name,
+                        theme=theme,
+                        line_numbers=True,
+                        line_range=(
+                            frame.lineno - self.extra_lines,
+                            frame.lineno + self.extra_lines,
+                        ),
+                        highlight_lines={frame.lineno},
+                        word_wrap=self.word_wrap,
+                        code_width=self.code_width,
+                        indent_guides=self.indent_guides,
+                        dedent=False,
+                    )
+                    yield ""
+                except Exception as error:
+                    yield Text.assemble(
+                        (f"\n{error}", "traceback.error"),
+                    )
+                else:
+                    if frame.last_instruction is not None:
+                        start, end = frame.last_instruction
+                        syntax.stylize_range(
+                            style="traceback.error_range",
+                            start=start,
+                            end=end,
+                            style_before=True,
+                        )
+                    yield (
+                        Columns(
+                            [
+                                syntax,
+                                *render_locals(frame),
+                            ],
+                            padding=1,
+                        )
+                        if frame.locals
+                        else syntax
+                    )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    install(show_locals=True)
+    import sys
+
+    def bar(
+        a: Any,
+    ) -> None:  # 这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑
+        one = 1
+        print(one / a)
+
+    def foo(a: Any) -> None:
+        _rich_traceback_guard = True
+        zed = {
+            "characters": {
+                "Paul Atreides",
+                "Vladimir Harkonnen",
+                "Thufir Hawat",
+                "Duncan Idaho",
+            },
+            "atomic_types": (None, False, True),
+        }
+        bar(a)
+
+    def error() -> None:
+        foo(0)
+
+    error()

minigpt2/lib/python3.10/site-packages/imageio/config/__init__.py

@@ -0,0 +1,16 @@
+from .extensions import (
+    extension_list,
+    known_extensions,
+    FileExtension,
+    video_extensions,
+)
+from .plugins import known_plugins, PluginConfig
+
+__all__ = [
+    "known_plugins",
+    "PluginConfig",
+    "extension_list",
+    "known_extensions",
+    "FileExtension",
+    "video_extensions",
+]

minigpt2/lib/python3.10/site-packages/imageio/config/extensions.py

@@ -0,0 +1,2002 @@
+"""
+A set of objects representing each file extension recognized by ImageIO. If an
+extension is not listed here it is still supported, as long as there exists a
+supporting backend.
+
+"""
+
+
+class FileExtension:
+    """File Extension Metadata
+
+    This class holds information about a image file format associated with a
+    given extension. This information is used to track plugins that are known to
+    be able to handle a particular format. It also contains additional
+    information about a format, which is used when creating the supported format
+    docs.
+
+    Plugins known to be able to handle this format are ordered by a ``priority``
+    list. This list is used to determine the ideal plugin to use when choosing a
+    plugin based on file extension.
+
+    Parameters
+    ----------
+    extension : str
+        The name of the extension including the initial dot, e.g. ".png".
+    priority : List
+        A list of plugin names (entries in config.known_plugins) that can handle
+        this format. The position of a plugin expresses a preference, e.g.
+        ["plugin1", "plugin2"] indicates that, if available, plugin1 should be
+        preferred over plugin2 when handling a request related to this format.
+    name : str
+        The full name of the format.
+    description : str
+        A description of the format.
+    external_link : str
+        A link to further information about the format. Typically, the format's
+        specification.
+    volume_support : str
+        If True, the format/extension supports volumetric image data.
+
+    Examples
+    --------
+    >>> FileExtension(
+            name="Bitmap",
+            extension=".bmp",
+            priority=["pillow", "BMP-PIL", "BMP-FI", "ITK"],
+            external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+        )
+
+    """
+
+    def __init__(
+        self,
+        *,
+        extension,
+        priority,
+        name=None,
+        description=None,
+        external_link=None,
+        volume_support=False
+    ):
+        self.extension = extension
+        self.priority = priority
+        self.name = name
+        self.description = description
+        self.external_link = external_link
+        self.default_priority = priority.copy()
+        self.volume_support = volume_support
+
+    def reset(self):
+        self.priority = self.default_priority.copy()
+
+
+extension_list = [
+    FileExtension(
+        name="Hasselblad raw",
+        extension=".3fr",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Sony alpha",
+        extension=".arw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Animated Portable Network Graphics",
+        external_link="https://en.wikipedia.org/wiki/APNG",
+        extension=".apng",
+        priority=["pillow", "pyav"],
+    ),
+    FileExtension(
+        name="Audio Video Interleave",
+        extension=".avi",
+        priority=["FFMPEG"],
+    ),
+    FileExtension(
+        name="Casio raw format",
+        extension=".bay",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".blp",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Bitmap",
+        extension=".bmp",
+        priority=["pillow", "BMP-PIL", "BMP-FI", "ITK", "pyav", "opencv"],
+        external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+    ),
+    FileExtension(
+        name="Device-Independent Bitmap",
+        extension=".dip",
+        priority=["opencv"],
+        external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+    ),
+    FileExtension(
+        name="Re-Volt mipmap",
+        extension=".bmq",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Binary Structured Data Format",
+        extension=".bsdf",
+        priority=["BSDF"],
+        external_link="http://bsdf.io/",
+    ),
+    FileExtension(
+        name="Binary Universal Form for the Representation of meteorological data",
+        extension=".bufr",
+        priority=["pillow", "BUFR-PIL"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".bw",
+        priority=["pillow", "SGI-PIL", "SGI-FI"],
+    ),
+    FileExtension(
+        name="Scirra Construct",
+        extension=".cap",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="AMETEK High Speed Camera Format",
+        extension=".cine",
+        priority=["RAW-FI"],
+        external_link="https://phantomhighspeed-knowledge.secure.force.com/servlet/fileField?id=0BE1N000000kD2i#:~:text=Cine%20is%20a%20video%20file,camera%20model%20and%20image%20resolution",
+    ),
+    FileExtension(extension=".cr2", priority=["RAW-FI"]),
+    FileExtension(
+        extension=".crw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".cs1",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Computerized Tomography",
+        extension=".ct",
+        priority=["DICOM"],
+    ),
+    FileExtension(
+        name="Windows Cursor Icons",
+        extension=".cur",
+        priority=["pillow", "CUR-PIL"],
+    ),
+    FileExtension(
+        name="Dr. Halo",
+        extension=".cut",
+        priority=["CUT-FI"],
+    ),
+    FileExtension(
+        extension=".dc2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="DICOM file format",
+        extension=".dcm",
+        priority=["DICOM", "ITK"],
+    ),
+    FileExtension(
+        extension=".dcr",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Intel DCX",
+        extension=".dcx",
+        priority=["pillow", "DCX-PIL"],
+    ),
+    FileExtension(
+        name="DirectX Texture Container",
+        extension=".dds",
+        priority=["pillow", "DDS-FI", "DDS-PIL"],
+    ),
+    FileExtension(
+        name="Windows Bitmap",
+        extension=".dib",
+        priority=["pillow", "DIB-PIL"],
+    ),
+    FileExtension(
+        name="DICOM file format",
+        extension=".dicom",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".dng",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".drf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".dsc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Enhanced Compression Wavelet",
+        extension=".ecw",
+        priority=["GDAL"],
+    ),
+    FileExtension(
+        name="Windows Metafile",
+        extension=".emf",
+        priority=["pillow", "WMF-PIL"],
+    ),
+    FileExtension(
+        name="Encapsulated Postscript",
+        extension=".eps",
+        priority=["pillow", "EPS-PIL"],
+    ),
+    FileExtension(
+        extension=".erf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="OpenEXR",
+        extension=".exr",
+        external_link="https://openexr.readthedocs.io/en/latest/",
+        priority=["EXR-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        extension=".fff",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fit",
+        priority=["pillow", "FITS-PIL", "FITS"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fits",
+        priority=["pillow", "FITS-PIL", "FITS", "pyav"],
+    ),
+    FileExtension(
+        name="Autodesk FLC Animation",
+        extension=".flc",
+        priority=["pillow", "FLI-PIL"],
+    ),
+    FileExtension(
+        name="Autodesk FLI Animation",
+        extension=".fli",
+        priority=["pillow", "FLI-PIL"],
+    ),
+    FileExtension(
+        name="Kodak FlashPix",
+        extension=".fpx",
+        priority=["pillow", "FPX-PIL"],
+    ),
+    FileExtension(
+        name="Independence War 2: Edge Of Chaos Texture Format",
+        extension=".ftc",
+        priority=["pillow", "FTEX-PIL"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fts",
+        priority=["FITS"],
+    ),
+    FileExtension(
+        name="Independence War 2: Edge Of Chaos Texture Format",
+        extension=".ftu",
+        priority=["pillow", "FTEX-PIL"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fz",
+        priority=["FITS"],
+    ),
+    FileExtension(
+        name="Raw fax format CCITT G.3",
+        extension=".g3",
+        priority=["G3-FI"],
+    ),
+    FileExtension(
+        name="GIMP brush file",
+        extension=".gbr",
+        priority=["pillow", "GBR-PIL"],
+    ),
+    FileExtension(
+        name="Grassroots DICOM",
+        extension=".gdcm",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Graphics Interchange Format",
+        extension=".gif",
+        priority=["pillow", "GIF-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="UMDS GIPL",
+        extension=".gipl",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="gridded meteorological data",
+        extension=".grib",
+        priority=["pillow", "GRIB-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".h5",
+        priority=["pillow", "HDF5-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".hdf",
+        priority=["pillow", "HDF5-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".hdf5",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".hdp",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        name="High Dynamic Range Image",
+        extension=".hdr",
+        priority=["HDR-FI", "ITK", "opencv"],
+    ),
+    FileExtension(
+        extension=".ia",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".icb",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Mac OS Icon File",
+        extension=".icns",
+        priority=["pillow", "ICNS-PIL"],
+    ),
+    FileExtension(
+        name="Windows Icon File",
+        extension=".ico",
+        priority=["pillow", "ICO-FI", "ICO-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="ILBM Interleaved Bitmap",
+        extension=".iff",
+        priority=["IFF-FI"],
+    ),
+    FileExtension(
+        name="IPTC/NAA",
+        extension=".iim",
+        priority=["pillow", "IPTC-PIL"],
+    ),
+    FileExtension(
+        extension=".iiq",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="IFUNC Image Memory",
+        extension=".im",
+        priority=["pillow", "IM-PIL"],
+    ),
+    FileExtension(
+        extension=".img",
+        priority=["ITK", "GDAL"],
+    ),
+    FileExtension(
+        extension=".img.gz",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="IM Tools",
+        extension=".IMT",
+        priority=["pillow", "IMT-PIL"],
+    ),
+    FileExtension(
+        name="Image Processing Lab",
+        extension=".ipl",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".j2c",
+        priority=["pillow", "J2K-FI", "JPEG2000-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".j2k",
+        priority=["pillow", "J2K-FI", "JPEG2000-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jfif",
+        priority=["pillow", "JPEG-PIL"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jif",
+        priority=["JPEG-FI"],
+    ),
+    FileExtension(
+        name="JPEG Network Graphics",
+        extension=".jng",
+        priority=["JNG-FI"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jp2",
+        priority=["pillow", "JP2-FI", "JPEG2000-PIL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpc",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jpe",
+        priority=["pillow", "JPEG-FI", "JPEG-PIL", "opencv"],
+    ),
+    FileExtension(
+        name="Joint Photographic Experts Group",
+        extension=".jpeg",
+        priority=["pillow", "JPEG-PIL", "JPEG-FI", "ITK", "GDAL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpf",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="Joint Photographic Experts Group",
+        extension=".jpg",
+        priority=["pillow", "JPEG-PIL", "JPEG-FI", "ITK", "GDAL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpx",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".jxr",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        extension=".k25",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".kc2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".kdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="C64 Koala Graphics",
+        extension=".koa",
+        priority=["KOALA-FI"],
+    ),
+    FileExtension(
+        name="ILBM Interleaved Bitmap",
+        extension=".lbm",
+        priority=["IFF-FI"],
+    ),
+    FileExtension(
+        name="Lytro F01",
+        extension=".lfp",
+        priority=["LYTRO-LFP"],
+    ),
+    FileExtension(
+        name="Lytro Illum",
+        extension=".lfr",
+        priority=["LYTRO-LFR"],
+    ),
+    FileExtension(
+        name="ZEISS LSM",
+        extension=".lsm",
+        priority=["tifffile", "ITK", "TIFF"],
+    ),
+    FileExtension(
+        name="McIdas area file",
+        extension=".MCIDAS",
+        priority=["pillow", "MCIDAS-PIL"],
+        external_link="https://www.ssec.wisc.edu/mcidas/doc/prog_man/2003print/progman2003-formats.html",
+    ),
+    FileExtension(
+        extension=".mdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".mef",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="FreeSurfer File Format",
+        extension=".mgh",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="ITK MetaImage",
+        extension=".mha",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="ITK MetaImage Header",
+        extension=".mhd",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Microsoft Image Composer",
+        extension=".mic",
+        priority=["pillow", "MIC-PIL"],
+    ),
+    FileExtension(
+        name="Matroska Multimedia Container",
+        extension=".mkv",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Medical Imaging NetCDF",
+        extension=".mnc",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Medical Imaging NetCDF 2",
+        extension=".mnc2",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Leaf Raw Image Format",
+        extension=".mos",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="QuickTime File Format",
+        extension=".mov",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="MPEG-4 Part 14",
+        extension=".mp4",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="MPEG-1 Moving Picture Experts Group",
+        extension=".mpeg",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Moving Picture Experts Group",
+        extension=".mpg",
+        priority=["pillow", "FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG Multi-Picture Format",
+        extension=".mpo",
+        priority=["pillow", "MPO-PIL"],
+    ),
+    FileExtension(
+        name="Magnetic resonance imaging",
+        extension=".mri",
+        priority=["DICOM"],
+    ),
+    FileExtension(
+        extension=".mrw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Windows Paint",
+        extension=".msp",
+        priority=["pillow", "MSP-PIL"],
+    ),
+    FileExtension(
+        extension=".nef",
+        priority=["RAW-FI", "rawpy"],
+    ),
+    FileExtension(
+        extension=".nhdr",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nia",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nii",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="nii.gz",
+        extension=".nii.gz",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Numpy Array",
+        extension=".npz",
+        priority=["NPZ"],
+        volume_support=True,
+    ),
+    FileExtension(
+        extension=".nrrd",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nrw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".orf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".palm",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Portable Bitmap",
+        extension=".pbm",
+        priority=["PGM-FI", "PGMRAW-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Kodak PhotoCD",
+        extension=".pcd",
+        priority=["pillow", "PCD-FI", "PCD-PIL"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pct",
+        priority=["PICT-FI"],
+    ),
+    FileExtension(
+        name="Zsoft Paintbrush",
+        extension=".PCX",
+        priority=["pillow", "PCX-FI", "PCX-PIL"],
+    ),
+    FileExtension(
+        extension=".pdf",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".pef",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".pfm",
+        priority=["PFM-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Greymap",
+        extension=".pgm",
+        priority=["pillow", "PGM-FI", "PGMRAW-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pic",
+        priority=["PICT-FI", "ITK", "opencv"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pict",
+        priority=["PICT-FI"],
+    ),
+    FileExtension(
+        name="Portable Network Graphics",
+        extension=".png",
+        priority=["pillow", "PNG-PIL", "PNG-FI", "ITK", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Image Format",
+        extension=".pnm",
+        priority=["pillow", "opencv"],
+    ),
+    FileExtension(
+        name="Pbmplus image",
+        extension=".ppm",
+        priority=["pillow", "PPM-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="Pbmplus image",
+        extension=".pbm",
+        priority=["pillow", "PPM-PIL", "PPM-FI"],
+    ),
+    FileExtension(
+        name="Portable image format",
+        extension=".pxm",
+        priority=["opencv"],
+    ),
+    FileExtension(
+        name="Portable Pixelmap (ASCII)",
+        extension=".ppm",
+        priority=["PPM-FI", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Pixelmap (Raw)",
+        extension=".ppm",
+        priority=["PPMRAW-FI"],
+    ),
+    FileExtension(
+        name="Ghostscript",
+        extension=".ps",
+        priority=["pillow", "EPS-PIL"],
+    ),
+    FileExtension(
+        name="Adope Photoshop 2.5 and 3.0",
+        extension=".psd",
+        priority=["pillow", "PSD-PIL", "PSD-FI"],
+    ),
+    FileExtension(
+        extension=".ptx",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".pxn",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="PIXAR raster image",
+        extension=".pxr",
+        priority=["pillow", "PIXAR-PIL"],
+    ),
+    FileExtension(
+        extension=".qtk",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".raf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Sun Raster File",
+        extension=".ras",
+        priority=["pillow", "SUN-PIL", "RAS-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Sun Raster File",
+        extension=".sr",
+        priority=["opencv"],
+    ),
+    FileExtension(
+        extension=".raw",
+        priority=["RAW-FI", "LYTRO-ILLUM-RAW", "LYTRO-F01-RAW", "rawpy"],
+    ),
+    FileExtension(
+        extension=".rdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".rgb",
+        priority=["pillow", "SGI-PIL"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".rgba",
+        priority=["pillow", "SGI-PIL"],
+    ),
+    FileExtension(
+        extension=".rw2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".rwl",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".rwz",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".sgi",
+        priority=["pillow", "SGI-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="SPE File Format",
+        extension=".spe",
+        priority=["SPE"],
+    ),
+    FileExtension(
+        extension=".SPIDER",
+        priority=["pillow", "SPIDER-PIL"],
+    ),
+    FileExtension(
+        extension=".sr2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".srf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".srw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".sti",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".stk",
+        priority=["tifffile", "TIFF"],
+    ),
+    FileExtension(
+        name="ShockWave Flash",
+        extension=".swf",
+        priority=["SWF", "pyav"],
+    ),
+    FileExtension(
+        name="Truevision TGA",
+        extension=".targa",
+        priority=["pillow", "TARGA-FI"],
+    ),
+    FileExtension(
+        name="Truevision TGA",
+        extension=".tga",
+        priority=["pillow", "TGA-PIL", "TARGA-FI", "pyav"],
+    ),
+    FileExtension(
+        name="Tagged Image File",
+        extension=".tif",
+        priority=[
+            "tifffile",
+            "TIFF",
+            "pillow",
+            "TIFF-PIL",
+            "TIFF-FI",
+            "FEI",
+            "ITK",
+            "GDAL",
+            "pyav",
+            "opencv",
+        ],
+        volume_support=True,
+    ),
+    FileExtension(
+        name="Tagged Image File Format",
+        extension=".tiff",
+        priority=[
+            "tifffile",
+            "TIFF",
+            "pillow",
+            "TIFF-PIL",
+            "TIFF-FI",
+            "FEI",
+            "ITK",
+            "GDAL",
+            "pyav",
+            "opencv",
+        ],
+        volume_support=True,
+    ),
+    FileExtension(
+        extension=".vda",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".vst",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".vtk",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wap",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wbm",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wbmp",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".wdp",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        name="Matroska",
+        extension=".webm",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Google WebP",
+        extension=".webp",
+        priority=["pillow", "WEBP-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Windows Meta File",
+        extension=".wmf",
+        priority=["pillow", "WMF-PIL"],
+    ),
+    FileExtension(
+        name="Windows Media Video",
+        extension=".wmv",
+        priority=["FFMPEG"],
+    ),
+    FileExtension(
+        name="X11 Bitmap",
+        extension=".xbm",
+        priority=["pillow", "XBM-PIL", "XBM-FI", "pyav"],
+    ),
+    FileExtension(
+        name="X11 Pixel Map",
+        extension=".xpm",
+        priority=["pillow", "XPM-PIL", "XPM-FI"],
+    ),
+    FileExtension(
+        name="Thumbnail Image",
+        extension=".XVTHUMB",
+        priority=["pillow", "XVTHUMB-PIL"],
+    ),
+    FileExtension(
+        extension=".dpx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im1",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im24",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im8",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".jls",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".ljpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pam",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pcx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pgmyuv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pix",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".ppm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".rs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".sun",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".sunras",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".xface",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".xwd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".y",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GPP AMR",
+        extension=".amr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="a64 - video for Commodore 64",
+        extension=".A64",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="a64 - video for Commodore 64",
+        extension=".a64",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Adobe Filmstrip",
+        extension=".flm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AMV",
+        extension=".amv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".asf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".asf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".wmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".wmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AV1 Annex B",
+        extension=".obu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AV1 low overhead OBU",
+        extension=".obu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AVI (Audio Video Interleaved)",
+        extension=".avi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AVR (Audio Visual Research)",
+        extension=".avr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Beam Software SIFF",
+        extension=".vb",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="CD Graphics",
+        extension=".cdg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Commodore CDXL video",
+        extension=".cdxl",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Commodore CDXL video",
+        extension=".xl",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DASH Muxer",
+        extension=".mpd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Digital Pictures SGA",
+        extension=".sga",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Discworld II BMV",
+        extension=".bmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DV (Digital Video)",
+        extension=".dif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DV (Digital Video)",
+        extension=".dv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="F4V Adobe Flash Video",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="FLV (Flash Video)",
+        extension=".flv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="GXF (General eXchange Format)",
+        extension=".gxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iCE Draw File",
+        extension=".idf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="IFV CCTV DVR",
+        extension=".ifv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="IVR (Internet Video Recording)",
+        extension=".ivr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Konami PS2 SVAG",
+        extension=".svag",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="KUX (YouKu)",
+        extension=".kux",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="live RTMP FLV (Flash Video)",
+        extension=".flv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Loki SDL MJPEG",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="LVF",
+        extension=".lvf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mk3d",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mka",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mks",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Microsoft XMV",
+        extension=".xmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MIME multipart JPEG",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MobiClip MODS",
+        extension=".mods",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MobiClip MOFLEX",
+        extension=".moflex",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Motion Pixels MVI",
+        extension=".mvi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (DVD VOB)",
+        extension=".dvd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (SVCD)",
+        extension=".vob",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (VOB)",
+        extension=".vob",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".m2t",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".m2ts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".mts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".ts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Musepack",
+        extension=".mpc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MXF (Material eXchange Format) Operational Pattern Atom",
+        extension=".mxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MXF (Material eXchange Format)",
+        extension=".mxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MxPEG clip",
+        extension=".mxg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="NC camera feed",
+        extension=".v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="NUT",
+        extension=".nut",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Ogg Video",
+        extension=".ogv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Ogg",
+        extension=".ogg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="On2 IVF",
+        extension=".ivf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="PSP MP4 (MPEG-4 Part 14)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Psygnosis YOP",
+        extension=".yop",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS2-P2/IEEE1857.4 video",
+        extension=".avs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS2-P2/IEEE1857.4 video",
+        extension=".avs2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS3-P2/IEEE1857.10",
+        extension=".avs3",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Chinese AVS (Audio Video Standard) video",
+        extension=".cavs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Dirac",
+        extension=".drc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Dirac",
+        extension=".vc2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw DNxHD (SMPTE VC-3)",
+        extension=".dnxhd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw DNxHD (SMPTE VC-3)",
+        extension=".dnxhr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw GSM",
+        extension=".gsm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.261",
+        extension=".h261",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.263",
+        extension=".h263",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".264",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".avc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".h264",
+        priority=["pyav", "FFMPEG"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".h26l",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".265",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".h265",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".hevc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw id RoQ",
+        extension=".roq",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Ingenient MJPEG",
+        extension=".cgi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw IPU Video",
+        extension=".ipu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG 2000 video",
+        extension=".j2k",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mjpeg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mpo",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".m1v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".mpeg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".mpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-2 video",
+        extension=".m2v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-4 video",
+        extension=".m4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw VC-1 video",
+        extension=".vc1",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".cif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".qcif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".rgb",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".yuv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="RealMedia",
+        extension=".rm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="SDR2",
+        extension=".sdr2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Sega FILM / CPK",
+        extension=".cpk",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="SER (Simple uncompressed video format for astronomical capturing)",
+        extension=".ser",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Simbiosis Interactive IMX",
+        extension=".imx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Square SVS",
+        extension=".svs",
+        priority=["tifffile", "pyav"],
+    ),
+    FileExtension(
+        name="TiVo TY Stream",
+        extension=".ty",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="TiVo TY Stream",
+        extension=".ty+",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Uncompressed 4:2:2 10-bit",
+        extension=".v210",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Uncompressed 4:2:2 10-bit",
+        extension=".yuv10",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="VC-1 test bitstream",
+        extension=".rcv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Video CCTV DAT",
+        extension=".dat",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Video DAV",
+        extension=".dav",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Vivo",
+        extension=".viv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM Chunk Muxer",
+        extension=".chk",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mk3d",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mka",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mks",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Windows Television (WTV)",
+        extension=".wtv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Xilam DERF",
+        extension=".adp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="YUV4MPEG pipe",
+        extension=".y4m",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".qpi",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="PCO Camera",
+        extension=".pcoraw",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="PCO Camera",
+        extension=".rec",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Perkin Elmer Vectra",
+        extension=".qptiff",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Pyramid Encoded TIFF",
+        extension=".ptiff",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Pyramid Encoded TIFF",
+        extension=".ptif",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Opticks Gel",
+        extension=".gel",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Zoomify Image Format",
+        extension=".zif",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Hamamatsu Slide Scanner",
+        extension=".ndpi",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="Roche Digital Pathology",
+        extension=".bif",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        extension=".tf8",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        extension=".btf",
+        priority=["tifffile"],
+    ),
+    FileExtension(
+        name="High Efficiency Image File Format",
+        extension=".heic",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="AV1 Image File Format",
+        extension=".avif",
+        priority=["pillow"],
+    ),
+]
+extension_list.sort(key=lambda x: x.extension)
+
+
+known_extensions = dict()
+for ext in extension_list:
+    if ext.extension not in known_extensions:
+        known_extensions[ext.extension] = list()
+    known_extensions[ext.extension].append(ext)
+
+extension_list = [ext for ext_list in known_extensions.values() for ext in ext_list]
+
+_video_extension_strings = [
+    ".264",
+    ".265",
+    ".3g2",
+    ".3gp",
+    ".a64",
+    ".A64",
+    ".adp",
+    ".amr",
+    ".amv",
+    ".asf",
+    ".avc",
+    ".avi",
+    ".avr",
+    ".avs",
+    ".avs2",
+    ".avs3",
+    ".bmv",
+    ".cavs",
+    ".cdg",
+    ".cdxl",
+    ".cgi",
+    ".chk",
+    ".cif",
+    ".cpk",
+    ".dat",
+    ".dav",
+    ".dif",
+    ".dnxhd",
+    ".dnxhr",
+    ".drc",
+    ".dv",
+    ".dvd",
+    ".f4v",
+    ".flm",
+    ".flv",
+    ".gsm",
+    ".gxf",
+    ".h261",
+    ".h263",
+    ".h264",
+    ".h265",
+    ".h26l",
+    ".hevc",
+    ".idf",
+    ".ifv",
+    ".imx",
+    ".ipu",
+    ".ism",
+    ".isma",
+    ".ismv",
+    ".ivf",
+    ".ivr",
+    ".j2k",
+    ".kux",
+    ".lvf",
+    ".m1v",
+    ".m2t",
+    ".m2ts",
+    ".m2v",
+    ".m4a",
+    ".m4b",
+    ".m4v",
+    ".mj2",
+    ".mjpeg",
+    ".mjpg",
+    ".mk3d",
+    ".mka",
+    ".mks",
+    ".mkv",
+    ".mods",
+    ".moflex",
+    ".mov",
+    ".mp4",
+    ".mpc",
+    ".mpd",
+    ".mpeg",
+    ".mpg",
+    ".mpo",
+    ".mts",
+    ".mvi",
+    ".mxf",
+    ".mxg",
+    ".nut",
+    ".obu",
+    ".ogg",
+    ".ogv",
+    ".psp",
+    ".qcif",
+    ".rcv",
+    ".rgb",
+    ".rm",
+    ".roq",
+    ".sdr2",
+    ".ser",
+    ".sga",
+    ".svag",
+    ".svs",
+    ".ts",
+    ".ty",
+    ".ty+",
+    ".v",
+    ".v210",
+    ".vb",
+    ".vc1",
+    ".vc2",
+    ".viv",
+    ".vob",
+    ".webm",
+    ".wmv",
+    ".wtv",
+    ".xl",
+    ".xmv",
+    ".y4m",
+    ".yop",
+    ".yuv",
+    ".yuv10",
+]
+video_extensions = list()
+for ext_string in _video_extension_strings:
+    formats = known_extensions[ext_string]
+    video_extensions.append(formats[0])
+video_extensions.sort(key=lambda x: x.extension)

minigpt2/lib/python3.10/site-packages/imageio/config/extensions.pyi

@@ -0,0 +1,24 @@
+from typing import List, Dict, Optional
+
+class FileExtension:
+    extension: str
+    priority: List[str]
+    name: Optional[str] = None
+    description: Optional[str] = None
+    external_link: Optional[str] = None
+    volume_support: bool
+
+    def __init__(
+        self,
+        *,
+        extension: str,
+        priority: List[str],
+        name: str = None,
+        description: str = None,
+        external_link: str = None
+    ) -> None: ...
+    def reset(self) -> None: ...
+
+extension_list: List[FileExtension]
+known_extensions: Dict[str, List[FileExtension]]
+video_extensions: List[FileExtension]

minigpt2/lib/python3.10/site-packages/imageio/config/plugins.py

@@ -0,0 +1,782 @@
+import importlib
+
+from ..core.legacy_plugin_wrapper import LegacyPlugin
+
+
+class PluginConfig:
+    """Plugin Configuration Metadata
+
+    This class holds the information needed to lazy-import plugins.
+
+    Parameters
+    ----------
+    name : str
+        The name of the plugin.
+    class_name : str
+        The name of the plugin class inside the plugin module.
+    module_name : str
+        The name of the module/package from which to import the plugin.
+    is_legacy : bool
+        If True, this plugin is a v2 plugin and will be wrapped in a
+        LegacyPlugin. Default: False.
+    package_name : str
+        If the given module name points to a relative module, then the package
+        name determines the package it is relative to.
+    install_name : str
+        The name of the optional dependency that can be used to install this
+        plugin if it is missing.
+    legacy_args : Dict
+        A dictionary of kwargs to pass to the v2 plugin (Format) upon construction.
+
+    Examples
+    --------
+    >>> PluginConfig(
+            name="TIFF",
+            class_name="TiffFormat",
+            module_name="imageio.plugins.tifffile",
+            is_legacy=True,
+            install_name="tifffile",
+            legacy_args={
+                "description": "TIFF format",
+                "extensions": ".tif .tiff .stk .lsm",
+                "modes": "iIvV",
+            },
+        )
+    >>> PluginConfig(
+            name="pillow",
+            class_name="PillowPlugin",
+            module_name="imageio.plugins.pillow"
+        )
+
+    """
+
+    def __init__(
+        self,
+        name,
+        class_name,
+        module_name,
+        *,
+        is_legacy=False,
+        package_name=None,
+        install_name=None,
+        legacy_args=None,
+    ):
+        legacy_args = legacy_args or dict()
+
+        self.name = name
+        self.class_name = class_name
+        self.module_name = module_name
+        self.package_name = package_name
+
+        self.is_legacy = is_legacy
+        self.install_name = install_name or self.name
+        self.legacy_args = {"name": name, "description": "A legacy plugin"}
+        self.legacy_args.update(legacy_args)
+
+    @property
+    def format(self):
+        """For backwards compatibility with FormatManager
+
+        Delete when migrating to v3
+        """
+        if not self.is_legacy:
+            raise RuntimeError("Can only get format for legacy plugins.")
+
+        module = importlib.import_module(self.module_name, self.package_name)
+        clazz = getattr(module, self.class_name)
+        return clazz(**self.legacy_args)
+
+    @property
+    def plugin_class(self):
+        """Get the plugin class (import if needed)
+
+        Returns
+        -------
+        plugin_class : Any
+            The class that can be used to instantiate plugins.
+
+        """
+
+        module = importlib.import_module(self.module_name, self.package_name)
+        clazz = getattr(module, self.class_name)
+
+        if self.is_legacy:
+            legacy_plugin = clazz(**self.legacy_args)
+
+            def partial_legacy_plugin(request):
+                return LegacyPlugin(request, legacy_plugin)
+
+            clazz = partial_legacy_plugin
+
+        return clazz
+
+
+known_plugins = dict()
+known_plugins["pillow"] = PluginConfig(
+    name="pillow", class_name="PillowPlugin", module_name="imageio.plugins.pillow"
+)
+known_plugins["pyav"] = PluginConfig(
+    name="pyav", class_name="PyAVPlugin", module_name="imageio.plugins.pyav"
+)
+known_plugins["opencv"] = PluginConfig(
+    name="opencv", class_name="OpenCVPlugin", module_name="imageio.plugins.opencv"
+)
+known_plugins["tifffile"] = PluginConfig(
+    name="tifffile",
+    class_name="TifffilePlugin",
+    module_name="imageio.plugins.tifffile_v3",
+)
+known_plugins["SPE"] = PluginConfig(
+    name="spe", class_name="SpePlugin", module_name="imageio.plugins.spe"
+)
+known_plugins["rawpy"] = PluginConfig(
+    name="rawpy", class_name="RawPyPlugin", module_name="imageio.plugins.rawpy"
+)
+
+# Legacy plugins
+# ==============
+#
+# Which are partly registered by format, partly by plugin, and partly by a mix
+# of both. We keep the naming here for backwards compatibility.
+# In v3 this should become a single entry per plugin named after the plugin
+# We can choose extension-specific priority in ``config.extensions``.
+#
+# Note: Since python 3.7 order of insertion determines the order of dict().keys()
+# This means that the order here determines the order by which plugins are
+# checked during the full fallback search. We don't advertise this downstream,
+# but it could be a useful thing to keep in mind to choose a sensible default
+# search order.
+
+known_plugins["TIFF"] = PluginConfig(
+    name="TIFF",
+    class_name="TiffFormat",
+    module_name="imageio.plugins.tifffile",
+    is_legacy=True,
+    install_name="tifffile",
+    legacy_args={
+        "description": "TIFF format",
+        "extensions": ".tif .tiff .stk .lsm",
+        "modes": "iIvV",
+    },
+)
+
+# PILLOW plugin formats (legacy)
+PILLOW_FORMATS = [
+    ("BMP", "Windows Bitmap", ".bmp", "PillowFormat"),
+    ("BUFR", "BUFR", ".bufr", "PillowFormat"),
+    ("CUR", "Windows Cursor", ".cur", "PillowFormat"),
+    ("DCX", "Intel DCX", ".dcx", "PillowFormat"),
+    ("DDS", "DirectDraw Surface", ".dds", "PillowFormat"),
+    ("DIB", "Windows Bitmap", "", "PillowFormat"),
+    ("EPS", "Encapsulated Postscript", ".ps .eps", "PillowFormat"),
+    ("FITS", "FITS", ".fit .fits", "PillowFormat"),
+    ("FLI", "Autodesk FLI/FLC Animation", ".fli .flc", "PillowFormat"),
+    ("FPX", "FlashPix", ".fpx", "PillowFormat"),
+    ("FTEX", "Texture File Format (IW2:EOC)", ".ftc .ftu", "PillowFormat"),
+    ("GBR", "GIMP brush file", ".gbr", "PillowFormat"),
+    ("GIF", "Compuserve GIF", ".gif", "GIFFormat"),
+    ("GRIB", "GRIB", ".grib", "PillowFormat"),
+    ("HDF5", "HDF5", ".h5 .hdf", "PillowFormat"),
+    ("ICNS", "Mac OS icns resource", ".icns", "PillowFormat"),
+    ("ICO", "Windows Icon", ".ico", "PillowFormat"),
+    ("IM", "IFUNC Image Memory", ".im", "PillowFormat"),
+    ("IMT", "IM Tools", "", "PillowFormat"),
+    ("IPTC", "IPTC/NAA", ".iim", "PillowFormat"),
+    ("JPEG", "JPEG (ISO 10918)", ".jfif .jpe .jpg .jpeg", "JPEGFormat"),
+    (
+        "JPEG2000",
+        "JPEG 2000 (ISO 15444)",
+        ".jp2 .j2k .jpc .jpf .jpx .j2c",
+        "JPEG2000Format",
+    ),
+    ("MCIDAS", "McIdas area file", "", "PillowFormat"),
+    ("MIC", "Microsoft Image Composer", ".mic", "PillowFormat"),
+    # skipped in legacy pillow
+    # ("MPEG", "MPEG", ".mpg .mpeg", "PillowFormat"),
+    ("MPO", "MPO (CIPA DC-007)", ".mpo", "PillowFormat"),
+    ("MSP", "Windows Paint", ".msp", "PillowFormat"),
+    ("PCD", "Kodak PhotoCD", ".pcd", "PillowFormat"),
+    ("PCX", "Paintbrush", ".pcx", "PillowFormat"),
+    ("PIXAR", "PIXAR raster image", ".pxr", "PillowFormat"),
+    ("PNG", "Portable network graphics", ".png", "PNGFormat"),
+    ("PPM", "Pbmplus image", ".pbm .pgm .ppm", "PillowFormat"),
+    ("PSD", "Adobe Photoshop", ".psd", "PillowFormat"),
+    ("SGI", "SGI Image File Format", ".bw .rgb .rgba .sgi", "PillowFormat"),
+    ("SPIDER", "Spider 2D image", "", "PillowFormat"),
+    ("SUN", "Sun Raster File", ".ras", "PillowFormat"),
+    ("TGA", "Targa", ".tga", "PillowFormat"),
+    ("TIFF", "Adobe TIFF", ".tif .tiff", "TIFFFormat"),
+    ("WMF", "Windows Metafile", ".wmf .emf", "PillowFormat"),
+    ("XBM", "X11 Bitmap", ".xbm", "PillowFormat"),
+    ("XPM", "X11 Pixel Map", ".xpm", "PillowFormat"),
+    ("XVTHUMB", "XV thumbnail image", "", "PillowFormat"),
+]
+for id, summary, ext, class_name in PILLOW_FORMATS:
+    config = PluginConfig(
+        name=id.upper() + "-PIL",
+        class_name=class_name,
+        module_name="imageio.plugins.pillow_legacy",
+        is_legacy=True,
+        install_name="pillow",
+        legacy_args={
+            "description": summary + " via Pillow",
+            "extensions": ext,
+            "modes": "iI" if class_name == "GIFFormat" else "i",
+            "plugin_id": id,
+        },
+    )
+    known_plugins[config.name] = config
+
+known_plugins["FFMPEG"] = PluginConfig(
+    name="FFMPEG",
+    class_name="FfmpegFormat",
+    module_name="imageio.plugins.ffmpeg",
+    is_legacy=True,
+    install_name="ffmpeg",
+    legacy_args={
+        "description": "Many video formats and cameras (via ffmpeg)",
+        "extensions": ".mov .avi .mpg .mpeg .mp4 .mkv .webm .wmv .h264",
+        "modes": "I",
+    },
+)
+
+known_plugins["BSDF"] = PluginConfig(
+    name="BSDF",
+    class_name="BsdfFormat",
+    module_name="imageio.plugins.bsdf",
+    is_legacy=True,
+    install_name="bsdf",
+    legacy_args={
+        "description": "Format based on the Binary Structured Data Format",
+        "extensions": ".bsdf",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["DICOM"] = PluginConfig(
+    name="DICOM",
+    class_name="DicomFormat",
+    module_name="imageio.plugins.dicom",
+    is_legacy=True,
+    install_name="dicom",
+    legacy_args={
+        "description": "Digital Imaging and Communications in Medicine",
+        "extensions": ".dcm .ct .mri",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["FEI"] = PluginConfig(
+    name="FEI",
+    class_name="FEISEMFormat",
+    module_name="imageio.plugins.feisem",
+    is_legacy=True,
+    install_name="feisem",
+    legacy_args={
+        "description": "FEI-SEM TIFF format",
+        "extensions": [".tif", ".tiff"],
+        "modes": "iv",
+    },
+)
+
+known_plugins["FITS"] = PluginConfig(
+    name="FITS",
+    class_name="FitsFormat",
+    module_name="imageio.plugins.fits",
+    is_legacy=True,
+    install_name="fits",
+    legacy_args={
+        "description": "Flexible Image Transport System (FITS) format",
+        "extensions": ".fits .fit .fts .fz",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["GDAL"] = PluginConfig(
+    name="GDAL",
+    class_name="GdalFormat",
+    module_name="imageio.plugins.gdal",
+    is_legacy=True,
+    install_name="gdal",
+    legacy_args={
+        "description": "Geospatial Data Abstraction Library",
+        "extensions": ".tiff  .tif .img .ecw .jpg .jpeg",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["ITK"] = PluginConfig(
+    name="ITK",
+    class_name="ItkFormat",
+    module_name="imageio.plugins.simpleitk",
+    is_legacy=True,
+    install_name="simpleitk",
+    legacy_args={
+        "description": "Insight Segmentation and Registration Toolkit (ITK) format",
+        "extensions": " ".join(
+            (
+                ".gipl",
+                ".ipl",
+                ".mha",
+                ".mhd",
+                ".nhdr",
+                ".nia",
+                ".hdr",
+                ".nrrd",
+                ".nii",
+                ".nii.gz",
+                ".img",
+                ".img.gz",
+                ".vtk",
+                ".hdf5",
+                ".lsm",
+                ".mnc",
+                ".mnc2",
+                ".mgh",
+                ".mnc",
+                ".pic",
+                ".bmp",
+                ".jpeg",
+                ".jpg",
+                ".png",
+                ".tiff",
+                ".tif",
+                ".dicom",
+                ".dcm",
+                ".gdcm",
+            )
+        ),
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["NPZ"] = PluginConfig(
+    name="NPZ",
+    class_name="NpzFormat",
+    module_name="imageio.plugins.npz",
+    is_legacy=True,
+    install_name="numpy",
+    legacy_args={
+        "description": "Numpy's compressed array format",
+        "extensions": ".npz",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["SWF"] = PluginConfig(
+    name="SWF",
+    class_name="SWFFormat",
+    module_name="imageio.plugins.swf",
+    is_legacy=True,
+    install_name="swf",
+    legacy_args={
+        "description": "Shockwave flash",
+        "extensions": ".swf",
+        "modes": "I",
+    },
+)
+
+known_plugins["SCREENGRAB"] = PluginConfig(
+    name="SCREENGRAB",
+    class_name="ScreenGrabFormat",
+    module_name="imageio.plugins.grab",
+    is_legacy=True,
+    install_name="pillow",
+    legacy_args={
+        "description": "Grab screenshots (Windows and OS X only)",
+        "extensions": [],
+        "modes": "i",
+    },
+)
+
+known_plugins["CLIPBOARDGRAB"] = PluginConfig(
+    name="CLIPBOARDGRAB",
+    class_name="ClipboardGrabFormat",
+    module_name="imageio.plugins.grab",
+    is_legacy=True,
+    install_name="pillow",
+    legacy_args={
+        "description": "Grab from clipboard (Windows only)",
+        "extensions": [],
+        "modes": "i",
+    },
+)
+
+# LYTRO plugin (legacy)
+lytro_formats = [
+    ("lytro-lfr", "Lytro Illum lfr image file", ".lfr", "i", "LytroLfrFormat"),
+    (
+        "lytro-illum-raw",
+        "Lytro Illum raw image file",
+        ".raw",
+        "i",
+        "LytroIllumRawFormat",
+    ),
+    ("lytro-lfp", "Lytro F01 lfp image file", ".lfp", "i", "LytroLfpFormat"),
+    ("lytro-f01-raw", "Lytro F01 raw image file", ".raw", "i", "LytroF01RawFormat"),
+]
+for name, des, ext, mode, class_name in lytro_formats:
+    config = PluginConfig(
+        name=name.upper(),
+        class_name=class_name,
+        module_name="imageio.plugins.lytro",
+        is_legacy=True,
+        install_name="lytro",
+        legacy_args={
+            "description": des,
+            "extensions": ext,
+            "modes": mode,
+        },
+    )
+    known_plugins[config.name] = config
+
+# FreeImage plugin (legacy)
+FREEIMAGE_FORMATS = [
+    (
+        "BMP",
+        0,
+        "Windows or OS/2 Bitmap",
+        ".bmp",
+        "i",
+        "FreeimageBmpFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "CUT",
+        21,
+        "Dr. Halo",
+        ".cut",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "DDS",
+        24,
+        "DirectX Surface",
+        ".dds",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "EXR",
+        29,
+        "ILM OpenEXR",
+        ".exr",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "G3",
+        27,
+        "Raw fax format CCITT G.3",
+        ".g3",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "GIF",
+        25,
+        "Static and animated gif (FreeImage)",
+        ".gif",
+        "iI",
+        "GifFormat",
+        "imageio.plugins.freeimagemulti",
+    ),
+    (
+        "HDR",
+        26,
+        "High Dynamic Range Image",
+        ".hdr",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "ICO",
+        1,
+        "Windows Icon",
+        ".ico",
+        "iI",
+        "IcoFormat",
+        "imageio.plugins.freeimagemulti",
+    ),
+    (
+        "IFF",
+        5,
+        "IFF Interleaved Bitmap",
+        ".iff .lbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "J2K",
+        30,
+        "JPEG-2000 codestream",
+        ".j2k .j2c",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JNG",
+        3,
+        "JPEG Network Graphics",
+        ".jng",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JP2",
+        31,
+        "JPEG-2000 File Format",
+        ".jp2",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JPEG",
+        2,
+        "JPEG - JFIF Compliant",
+        ".jpg .jif .jpeg .jpe",
+        "i",
+        "FreeimageJpegFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JPEG-XR",
+        36,
+        "JPEG XR image format",
+        ".jxr .wdp .hdp",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "KOALA",
+        4,
+        "C64 Koala Graphics",
+        ".koa",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    # not registered in legacy pillow
+    # ("MNG", 6, "Multiple-image Network Graphics", ".mng", "i", "FreeimageFormat", "imageio.plugins.freeimage"),
+    (
+        "PBM",
+        7,
+        "Portable Bitmap (ASCII)",
+        ".pbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PBMRAW",
+        8,
+        "Portable Bitmap (RAW)",
+        ".pbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PCD",
+        9,
+        "Kodak PhotoCD",
+        ".pcd",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PCX",
+        10,
+        "Zsoft Paintbrush",
+        ".pcx",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PFM",
+        32,
+        "Portable floatmap",
+        ".pfm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PGM",
+        11,
+        "Portable Greymap (ASCII)",
+        ".pgm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PGMRAW",
+        12,
+        "Portable Greymap (RAW)",
+        ".pgm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PICT",
+        33,
+        "Macintosh PICT",
+        ".pct .pict .pic",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PNG",
+        13,
+        "Portable Network Graphics",
+        ".png",
+        "i",
+        "FreeimagePngFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PPM",
+        14,
+        "Portable Pixelmap (ASCII)",
+        ".ppm",
+        "i",
+        "FreeimagePnmFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PPMRAW",
+        15,
+        "Portable Pixelmap (RAW)",
+        ".ppm",
+        "i",
+        "FreeimagePnmFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PSD",
+        20,
+        "Adobe Photoshop",
+        ".psd",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "RAS",
+        16,
+        "Sun Raster Image",
+        ".ras",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "RAW",
+        34,
+        "RAW camera image",
+        ".3fr .arw .bay .bmq .cap .cine .cr2 .crw .cs1 .dc2 "
+        ".dcr .drf .dsc .dng .erf .fff .ia .iiq .k25 .kc2 .kdc .mdc .mef .mos .mrw .nef .nrw .orf "
+        ".pef .ptx .pxn .qtk .raf .raw .rdc .rw2 .rwl .rwz .sr2 .srf .srw .sti",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "SGI",
+        28,
+        "SGI Image Format",
+        ".sgi .rgb .rgba .bw",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "TARGA",
+        17,
+        "Truevision Targa",
+        ".tga .targa",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "TIFF",
+        18,
+        "Tagged Image File Format",
+        ".tif .tiff",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "WBMP",
+        19,
+        "Wireless Bitmap",
+        ".wap .wbmp .wbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "WebP",
+        35,
+        "Google WebP image format",
+        ".webp",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "XBM",
+        22,
+        "X11 Bitmap Format",
+        ".xbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "XPM",
+        23,
+        "X11 Pixmap Format",
+        ".xpm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+]
+for name, i, des, ext, mode, class_name, module_name in FREEIMAGE_FORMATS:
+    config = PluginConfig(
+        name=name.upper() + "-FI",
+        class_name=class_name,
+        module_name=module_name,
+        is_legacy=True,
+        install_name="freeimage",
+        legacy_args={
+            "description": des,
+            "extensions": ext,
+            "modes": mode,
+            "fif": i,
+        },
+    )
+    known_plugins[config.name] = config
+
+# exists for backwards compatibility with FormatManager
+# delete in V3
+_original_order = [x for x, config in known_plugins.items() if config.is_legacy]

minigpt2/lib/python3.10/site-packages/imageio/config/plugins.pyi

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Optional
+from ..core.v3_plugin_api import PluginV3
+
+class PluginConfig:
+    name: str
+    class_name: str
+    module_name: str
+    is_legacy: bool
+    package_name: Optional[str] = None
+    install_name: Optional[str] = None
+    legacy_args: Optional[dict] = None
+    @property
+    def format(self) -> Any: ...
+    @property
+    def plugin_class(self) -> PluginV3: ...
+    def __init__(
+        self,
+        name: str,
+        class_name: str,
+        module_name: str,
+        *,
+        is_legacy: bool = False,
+        package_name: str = None,
+        install_name: str = None,
+        legacy_args: dict = None,
+    ) -> None: ...
+
+known_plugins: Dict[str, PluginConfig]

minigpt2/lib/python3.10/site-packages/imageio/freeze.py

@@ -0,0 +1,11 @@
+"""
+Helper functions for freezing imageio.
+"""
+
+
+def get_includes():
+    return ["email", "urllib.request", "numpy", "zipfile", "io"]
+
+
+def get_excludes():
+    return []

minigpt2/lib/python3.10/site-packages/imageio/plugins/__init__.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+# flake8: noqa
+
+"""
+Here you can find documentation on how to write your own plugin to allow
+ImageIO to access a new backend. Plugins are quite object oriented, and
+the relevant classes and their interaction are documented here:
+
+.. currentmodule:: imageio
+
+.. autosummary::
+    :toctree: ../_autosummary
+    :template: better_class.rst
+
+    imageio.core.Format
+    imageio.core.Request
+
+.. note::
+    You can always check existing plugins if you want to see examples.
+
+What methods to implement
+-------------------------
+
+To implement a new plugin, create a new class that inherits from
+:class:`imageio.core.Format`. and implement the following functions:
+
+.. autosummary::
+    :toctree: ../_autosummary
+
+    imageio.core.Format.__init__
+    imageio.core.Format._can_read
+    imageio.core.Format._can_write
+
+Further, each format contains up to two nested classes; one for reading and
+one for writing. To support reading and/or writing, the respective classes
+need to be defined.
+
+For reading, create a nested class that inherits from
+``imageio.core.Format.Reader`` and that implements the following functions:
+
+    * Implement ``_open(**kwargs)`` to initialize the reader. Deal with the
+        user-provided keyword arguments here.
+    * Implement ``_close()`` to clean up.
+    * Implement ``_get_length()`` to provide a suitable length based on what
+        the user expects. Can be ``inf`` for streaming data.
+    * Implement ``_get_data(index)`` to return an array and a meta-data dict.
+    * Implement ``_get_meta_data(index)`` to return a meta-data dict. If index
+        is None, it should return the 'global' meta-data.
+
+For writing, create a nested class that inherits from
+``imageio.core.Format.Writer`` and implement the following functions:
+
+    * Implement ``_open(**kwargs)`` to initialize the writer. Deal with the
+        user-provided keyword arguments here.
+    * Implement ``_close()`` to clean up.
+    * Implement ``_append_data(im, meta)`` to add data (and meta-data).
+    * Implement ``_set_meta_data(meta)`` to set the global meta-data.
+
+"""
+
+import importlib
+import os
+import warnings
+
+
+# v2 imports remove in v3
+from .. import formats
+
+# v2 allows formatting plugins by environment variable
+# this is done here.
+env_plugin_order = os.getenv("IMAGEIO_FORMAT_ORDER", None)
+if env_plugin_order is not None:  # pragma: no cover
+    warnings.warn(
+        "Setting plugin priority through an environment variable is"
+        " deprecated and will be removed in ImageIO v3. There is no"
+        " replacement planned for this feature. If you have an"
+        " active use-case for it, please reach out to us on GitHub.",
+        DeprecationWarning,
+    )
+
+    formats.sort(*os.getenv("IMAGEIO_FORMAT_ORDER", "").split(","))
+
+
+# this class replaces plugin module. For details
+# see https://stackoverflow.com/questions/2447353/getattr-on-a-module
+def __getattr__(name):
+    """Lazy-Import Plugins
+
+    This function dynamically loads plugins into the imageio.plugin
+    namespace upon first access. For example, the following snippet will
+    delay importing freeimage until the second line:
+
+    >>> import imageio
+    >>> imageio.plugins.freeimage.download()
+
+    """
+
+    try:
+        return importlib.import_module(f"imageio.plugins.{name}")
+    except ImportError:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'") from None

minigpt2/lib/python3.10/site-packages/imageio/plugins/_bsdf.py

@@ -0,0 +1,915 @@
+#!/usr/bin/env python
+# This file is distributed under the terms of the 2-clause BSD License.
+# Copyright (c) 2017-2018, Almar Klein
+
+"""
+Python implementation of the Binary Structured Data Format (BSDF).
+
+BSDF is a binary format for serializing structured (scientific) data.
+See http://bsdf.io for more information.
+
+This is the reference implementation, which is relatively relatively
+sophisticated, providing e.g. lazy loading of blobs and streamed
+reading/writing. A simpler Python implementation is available as
+``bsdf_lite.py``.
+
+This module has no dependencies and works on Python 2.7 and 3.4+.
+
+Note: on Legacy Python (Python 2.7), non-Unicode strings are encoded as bytes.
+"""
+
+# todo: in 2020, remove six stuff, __future__ and _isidentifier
+# todo: in 2020, remove 'utf-8' args to encode/decode; it's faster
+
+from __future__ import absolute_import, division, print_function
+
+import bz2
+import hashlib
+import logging
+import os
+import re
+import struct
+import sys
+import types
+import zlib
+from io import BytesIO
+
+logger = logging.getLogger(__name__)
+
+# Notes on versioning: the major and minor numbers correspond to the
+# BSDF format version. The major number if increased when backward
+# incompatible changes are introduced. An implementation must raise an
+# exception when the file being read has a higher major version. The
+# minor number is increased when new backward compatible features are
+# introduced. An implementation must display a warning when the file
+# being read has a higher minor version. The patch version is increased
+# for subsequent releases of the implementation.
+VERSION = 2, 1, 2
+__version__ = ".".join(str(i) for i in VERSION)
+
+
+# %% The encoder and decoder implementation
+
+# From six.py
+PY3 = sys.version_info[0] >= 3
+if PY3:
+    text_type = str
+    string_types = str
+    unicode_types = str
+    integer_types = int
+    classtypes = type
+else:  # pragma: no cover
+    logging.basicConfig()  # avoid "no handlers found" error
+    text_type = unicode  # noqa
+    string_types = basestring  # noqa
+    unicode_types = unicode  # noqa
+    integer_types = (int, long)  # noqa
+    classtypes = type, types.ClassType
+
+# Shorthands
+spack = struct.pack
+strunpack = struct.unpack
+
+
+def lencode(x):
+    """Encode an unsigned integer into a variable sized blob of bytes."""
+    # We could support 16 bit and 32 bit as well, but the gain is low, since
+    # 9 bytes for collections with over 250 elements is marginal anyway.
+    if x <= 250:
+        return spack("<B", x)
+    # elif x < 65536:
+    #     return spack('<BH', 251, x)
+    # elif x < 4294967296:
+    #     return spack('<BI', 252, x)
+    else:
+        return spack("<BQ", 253, x)
+
+
+# Include len decoder for completeness; we've inlined it for performance.
+def lendecode(f):
+    """Decode an unsigned integer from a file."""
+    n = strunpack("<B", f.read(1))[0]
+    if n == 253:
+        n = strunpack("<Q", f.read(8))[0]  # noqa
+    return n
+
+
+def encode_type_id(b, ext_id):
+    """Encode the type identifier, with or without extension id."""
+    if ext_id is not None:
+        bb = ext_id.encode("UTF-8")
+        return b.upper() + lencode(len(bb)) + bb  # noqa
+    else:
+        return b  # noqa
+
+
+def _isidentifier(s):  # pragma: no cover
+    """Use of str.isidentifier() for Legacy Python, but slower."""
+    # http://stackoverflow.com/questions/2544972/
+    return (
+        isinstance(s, string_types)
+        and re.match(r"^\w+$", s, re.UNICODE)
+        and re.match(r"^[0-9]", s) is None
+    )
+
+
+class BsdfSerializer(object):
+    """Instances of this class represent a BSDF encoder/decoder.
+
+    It acts as a placeholder for a set of extensions and encoding/decoding
+    options. Use this to predefine extensions and options for high
+    performance encoding/decoding. For general use, see the functions
+    `save()`, `encode()`, `load()`, and `decode()`.
+
+    This implementation of BSDF supports streaming lists (keep adding
+    to a list after writing the main file), lazy loading of blobs, and
+    in-place editing of blobs (for streams opened with a+).
+
+    Options for encoding:
+
+    * compression (int or str): ``0`` or "no" for no compression (default),
+      ``1`` or "zlib" for Zlib compression (same as zip files and PNG), and
+      ``2`` or "bz2" for Bz2 compression (more compact but slower writing).
+      Note that some BSDF implementations (e.g. JavaScript) may not support
+      compression.
+    * use_checksum (bool): whether to include a checksum with binary blobs.
+    * float64 (bool): Whether to write floats as 64 bit (default) or 32 bit.
+
+    Options for decoding:
+
+    * load_streaming (bool): if True, and the final object in the structure was
+      a stream, will make it available as a stream in the decoded object.
+    * lazy_blob (bool): if True, bytes are represented as Blob objects that can
+      be used to lazily access the data, and also overwrite the data if the
+      file is open in a+ mode.
+    """
+
+    def __init__(self, extensions=None, **options):
+        self._extensions = {}  # name -> extension
+        self._extensions_by_cls = {}  # cls -> (name, extension.encode)
+        if extensions is None:
+            extensions = standard_extensions
+        for extension in extensions:
+            self.add_extension(extension)
+        self._parse_options(**options)
+
+    def _parse_options(
+        self,
+        compression=0,
+        use_checksum=False,
+        float64=True,
+        load_streaming=False,
+        lazy_blob=False,
+    ):
+        # Validate compression
+        if isinstance(compression, string_types):
+            m = {"no": 0, "zlib": 1, "bz2": 2}
+            compression = m.get(compression.lower(), compression)
+        if compression not in (0, 1, 2):
+            raise TypeError("Compression must be 0, 1, 2, " '"no", "zlib", or "bz2"')
+        self._compression = compression
+
+        # Other encoding args
+        self._use_checksum = bool(use_checksum)
+        self._float64 = bool(float64)
+
+        # Decoding args
+        self._load_streaming = bool(load_streaming)
+        self._lazy_blob = bool(lazy_blob)
+
+    def add_extension(self, extension_class):
+        """Add an extension to this serializer instance, which must be
+        a subclass of Extension. Can be used as a decorator.
+        """
+        # Check class
+        if not (
+            isinstance(extension_class, type) and issubclass(extension_class, Extension)
+        ):
+            raise TypeError("add_extension() expects a Extension class.")
+        extension = extension_class()
+
+        # Get name
+        name = extension.name
+        if not isinstance(name, str):
+            raise TypeError("Extension name must be str.")
+        if len(name) == 0 or len(name) > 250:
+            raise NameError(
+                "Extension names must be nonempty and shorter " "than 251 chars."
+            )
+        if name in self._extensions:
+            logger.warning(
+                'BSDF warning: overwriting extension "%s", '
+                "consider removing first" % name
+            )
+
+        # Get classes
+        cls = extension.cls
+        if not cls:
+            clss = []
+        elif isinstance(cls, (tuple, list)):
+            clss = cls
+        else:
+            clss = [cls]
+        for cls in clss:
+            if not isinstance(cls, classtypes):
+                raise TypeError("Extension classes must be types.")
+
+        # Store
+        for cls in clss:
+            self._extensions_by_cls[cls] = name, extension.encode
+        self._extensions[name] = extension
+        return extension_class
+
+    def remove_extension(self, name):
+        """Remove a converted by its unique name."""
+        if not isinstance(name, str):
+            raise TypeError("Extension name must be str.")
+        if name in self._extensions:
+            self._extensions.pop(name)
+        for cls in list(self._extensions_by_cls.keys()):
+            if self._extensions_by_cls[cls][0] == name:
+                self._extensions_by_cls.pop(cls)
+
+    def _encode(self, f, value, streams, ext_id):
+        """Main encoder function."""
+        x = encode_type_id
+
+        if value is None:
+            f.write(x(b"v", ext_id))  # V for void
+        elif value is True:
+            f.write(x(b"y", ext_id))  # Y for yes
+        elif value is False:
+            f.write(x(b"n", ext_id))  # N for no
+        elif isinstance(value, integer_types):
+            if -32768 <= value <= 32767:
+                f.write(x(b"h", ext_id) + spack("h", value))  # H for ...
+            else:
+                f.write(x(b"i", ext_id) + spack("<q", value))  # I for int
+        elif isinstance(value, float):
+            if self._float64:
+                f.write(x(b"d", ext_id) + spack("<d", value))  # D for double
+            else:
+                f.write(x(b"f", ext_id) + spack("<f", value))  # f for float
+        elif isinstance(value, unicode_types):
+            bb = value.encode("UTF-8")
+            f.write(x(b"s", ext_id) + lencode(len(bb)))  # S for str
+            f.write(bb)
+        elif isinstance(value, (list, tuple)):
+            f.write(x(b"l", ext_id) + lencode(len(value)))  # L for list
+            for v in value:
+                self._encode(f, v, streams, None)
+        elif isinstance(value, dict):
+            f.write(x(b"m", ext_id) + lencode(len(value)))  # M for mapping
+            for key, v in value.items():
+                if PY3:
+                    assert key.isidentifier()  # faster
+                else:  # pragma: no cover
+                    assert _isidentifier(key)
+                # yield ' ' * indent + key
+                name_b = key.encode("UTF-8")
+                f.write(lencode(len(name_b)))
+                f.write(name_b)
+                self._encode(f, v, streams, None)
+        elif isinstance(value, bytes):
+            f.write(x(b"b", ext_id))  # B for blob
+            blob = Blob(
+                value, compression=self._compression, use_checksum=self._use_checksum
+            )
+            blob._to_file(f)  # noqa
+        elif isinstance(value, Blob):
+            f.write(x(b"b", ext_id))  # B for blob
+            value._to_file(f)  # noqa
+        elif isinstance(value, BaseStream):
+            # Initialize the stream
+            if value.mode != "w":
+                raise ValueError("Cannot serialize a read-mode stream.")
+            elif isinstance(value, ListStream):
+                f.write(x(b"l", ext_id) + spack("<BQ", 255, 0))  # L for list
+            else:
+                raise TypeError("Only ListStream is supported")
+            # Mark this as *the* stream, and activate the stream.
+            # The save() function verifies this is the last written object.
+            if len(streams) > 0:
+                raise ValueError("Can only have one stream per file.")
+            streams.append(value)
+            value._activate(f, self._encode, self._decode)  # noqa
+        else:
+            if ext_id is not None:
+                raise ValueError(
+                    "Extension %s wronfully encodes object to another "
+                    "extension object (though it may encode to a list/dict "
+                    "that contains other extension objects)." % ext_id
+                )
+            # Try if the value is of a type we know
+            ex = self._extensions_by_cls.get(value.__class__, None)
+            # Maybe its a subclass of a type we know
+            if ex is None:
+                for name, c in self._extensions.items():
+                    if c.match(self, value):
+                        ex = name, c.encode
+                        break
+                else:
+                    ex = None
+            # Success or fail
+            if ex is not None:
+                ext_id2, extension_encode = ex
+                self._encode(f, extension_encode(self, value), streams, ext_id2)
+            else:
+                t = (
+                    "Class %r is not a valid base BSDF type, nor is it "
+                    "handled by an extension."
+                )
+                raise TypeError(t % value.__class__.__name__)
+
+    def _decode(self, f):
+        """Main decoder function."""
+
+        # Get value
+        char = f.read(1)
+        c = char.lower()
+
+        # Conversion (uppercase value identifiers signify converted values)
+        if not char:
+            raise EOFError()
+        elif char != c:
+            n = strunpack("<B", f.read(1))[0]
+            # if n == 253: n = strunpack('<Q', f.read(8))[0]  # noqa - noneed
+            ext_id = f.read(n).decode("UTF-8")
+        else:
+            ext_id = None
+
+        if c == b"v":
+            value = None
+        elif c == b"y":
+            value = True
+        elif c == b"n":
+            value = False
+        elif c == b"h":
+            value = strunpack("<h", f.read(2))[0]
+        elif c == b"i":
+            value = strunpack("<q", f.read(8))[0]
+        elif c == b"f":
+            value = strunpack("<f", f.read(4))[0]
+        elif c == b"d":
+            value = strunpack("<d", f.read(8))[0]
+        elif c == b"s":
+            n_s = strunpack("<B", f.read(1))[0]
+            if n_s == 253:
+                n_s = strunpack("<Q", f.read(8))[0]  # noqa
+            value = f.read(n_s).decode("UTF-8")
+        elif c == b"l":
+            n = strunpack("<B", f.read(1))[0]
+            if n >= 254:
+                # Streaming
+                closed = n == 254
+                n = strunpack("<Q", f.read(8))[0]
+                if self._load_streaming:
+                    value = ListStream(n if closed else "r")
+                    value._activate(f, self._encode, self._decode)  # noqa
+                elif closed:
+                    value = [self._decode(f) for i in range(n)]
+                else:
+                    value = []
+                    try:
+                        while True:
+                            value.append(self._decode(f))
+                    except EOFError:
+                        pass
+            else:
+                # Normal
+                if n == 253:
+                    n = strunpack("<Q", f.read(8))[0]  # noqa
+                value = [self._decode(f) for i in range(n)]
+        elif c == b"m":
+            value = dict()
+            n = strunpack("<B", f.read(1))[0]
+            if n == 253:
+                n = strunpack("<Q", f.read(8))[0]  # noqa
+            for i in range(n):
+                n_name = strunpack("<B", f.read(1))[0]
+                if n_name == 253:
+                    n_name = strunpack("<Q", f.read(8))[0]  # noqa
+                assert n_name > 0
+                name = f.read(n_name).decode("UTF-8")
+                value[name] = self._decode(f)
+        elif c == b"b":
+            if self._lazy_blob:
+                value = Blob((f, True))
+            else:
+                blob = Blob((f, False))
+                value = blob.get_bytes()
+        else:
+            raise RuntimeError("Parse error %r" % char)
+
+        # Convert value if we have an extension for it
+        if ext_id is not None:
+            extension = self._extensions.get(ext_id, None)
+            if extension is not None:
+                value = extension.decode(self, value)
+            else:
+                logger.warning("BSDF warning: no extension found for %r" % ext_id)
+
+        return value
+
+    def encode(self, ob):
+        """Save the given object to bytes."""
+        f = BytesIO()
+        self.save(f, ob)
+        return f.getvalue()
+
+    def save(self, f, ob):
+        """Write the given object to the given file object."""
+        f.write(b"BSDF")
+        f.write(struct.pack("<B", VERSION[0]))
+        f.write(struct.pack("<B", VERSION[1]))
+
+        # Prepare streaming, this list will have 0 or 1 item at the end
+        streams = []
+
+        self._encode(f, ob, streams, None)
+
+        # Verify that stream object was at the end, and add initial elements
+        if len(streams) > 0:
+            stream = streams[0]
+            if stream._start_pos != f.tell():
+                raise ValueError(
+                    "The stream object must be " "the last object to be encoded."
+                )
+
+    def decode(self, bb):
+        """Load the data structure that is BSDF-encoded in the given bytes."""
+        f = BytesIO(bb)
+        return self.load(f)
+
+    def load(self, f):
+        """Load a BSDF-encoded object from the given file object."""
+        # Check magic string
+        f4 = f.read(4)
+        if f4 != b"BSDF":
+            raise RuntimeError("This does not look like a BSDF file: %r" % f4)
+        # Check version
+        major_version = strunpack("<B", f.read(1))[0]
+        minor_version = strunpack("<B", f.read(1))[0]
+        file_version = "%i.%i" % (major_version, minor_version)
+        if major_version != VERSION[0]:  # major version should be 2
+            t = (
+                "Reading file with different major version (%s) "
+                "from the implementation (%s)."
+            )
+            raise RuntimeError(t % (__version__, file_version))
+        if minor_version > VERSION[1]:  # minor should be < ours
+            t = (
+                "BSDF warning: reading file with higher minor version (%s) "
+                "than the implementation (%s)."
+            )
+            logger.warning(t % (__version__, file_version))
+
+        return self._decode(f)
+
+
+# %% Streaming and blob-files
+
+
+class BaseStream(object):
+    """Base class for streams."""
+
+    def __init__(self, mode="w"):
+        self._i = 0
+        self._count = -1
+        if isinstance(mode, int):
+            self._count = mode
+            mode = "r"
+        elif mode == "w":
+            self._count = 0
+        assert mode in ("r", "w")
+        self._mode = mode
+        self._f = None
+        self._start_pos = 0
+
+    def _activate(self, file, encode_func, decode_func):
+        if self._f is not None:  # Associated with another write
+            raise IOError("Stream object cannot be activated twice?")
+        self._f = file
+        self._start_pos = self._f.tell()
+        self._encode = encode_func
+        self._decode = decode_func
+
+    @property
+    def mode(self):
+        """The mode of this stream: 'r' or 'w'."""
+        return self._mode
+
+
+class ListStream(BaseStream):
+    """A streamable list object used for writing or reading.
+    In read mode, it can also be iterated over.
+    """
+
+    @property
+    def count(self):
+        """The number of elements in the stream (can be -1 for unclosed
+        streams in read-mode).
+        """
+        return self._count
+
+    @property
+    def index(self):
+        """The current index of the element to read/write."""
+        return self._i
+
+    def append(self, item):
+        """Append an item to the streaming list. The object is immediately
+        serialized and written to the underlying file.
+        """
+        # if self._mode != 'w':
+        #     raise IOError('This ListStream is not in write mode.')
+        if self._count != self._i:
+            raise IOError("Can only append items to the end of the stream.")
+        if self._f is None:
+            raise IOError("List stream is not associated with a file yet.")
+        if self._f.closed:
+            raise IOError("Cannot stream to a close file.")
+        self._encode(self._f, item, [self], None)
+        self._i += 1
+        self._count += 1
+
+    def close(self, unstream=False):
+        """Close the stream, marking the number of written elements. New
+        elements may still be appended, but they won't be read during decoding.
+        If ``unstream`` is False, the stream is turned into a regular list
+        (not streaming).
+        """
+        # if self._mode != 'w':
+        #     raise IOError('This ListStream is not in write mode.')
+        if self._count != self._i:
+            raise IOError("Can only close when at the end of the stream.")
+        if self._f is None:
+            raise IOError("ListStream is not associated with a file yet.")
+        if self._f.closed:
+            raise IOError("Cannot close a stream on a close file.")
+        i = self._f.tell()
+        self._f.seek(self._start_pos - 8 - 1)
+        self._f.write(spack("<B", 253 if unstream else 254))
+        self._f.write(spack("<Q", self._count))
+        self._f.seek(i)
+
+    def next(self):
+        """Read and return the next element in the streaming list.
+        Raises StopIteration if the stream is exhausted.
+        """
+        if self._mode != "r":
+            raise IOError("This ListStream in not in read mode.")
+        if self._f is None:
+            raise IOError("ListStream is not associated with a file yet.")
+        if getattr(self._f, "closed", None):  # not present on 2.7 http req :/
+            raise IOError("Cannot read a stream from a close file.")
+        if self._count >= 0:
+            if self._i >= self._count:
+                raise StopIteration()
+            self._i += 1
+            return self._decode(self._f)
+        else:
+            # This raises EOFError at some point.
+            try:
+                res = self._decode(self._f)
+                self._i += 1
+                return res
+            except EOFError:
+                self._count = self._i
+                raise StopIteration()
+
+    def __iter__(self):
+        if self._mode != "r":
+            raise IOError("Cannot iterate: ListStream in not in read mode.")
+        return self
+
+    def __next__(self):
+        return self.next()
+
+
+class Blob(object):
+    """Object to represent a blob of bytes. When used to write a BSDF file,
+    it's a wrapper for bytes plus properties such as what compression to apply.
+    When used to read a BSDF file, it can be used to read the data lazily, and
+    also modify the data if reading in 'r+' mode and the blob isn't compressed.
+    """
+
+    # For now, this does not allow re-sizing blobs (within the allocated size)
+    # but this can be added later.
+
+    def __init__(self, bb, compression=0, extra_size=0, use_checksum=False):
+        if isinstance(bb, bytes):
+            self._f = None
+            self.compressed = self._from_bytes(bb, compression)
+            self.compression = compression
+            self.allocated_size = self.used_size + extra_size
+            self.use_checksum = use_checksum
+        elif isinstance(bb, tuple) and len(bb) == 2 and hasattr(bb[0], "read"):
+            self._f, allow_seek = bb
+            self.compressed = None
+            self._from_file(self._f, allow_seek)
+            self._modified = False
+        else:
+            raise TypeError("Wrong argument to create Blob.")
+
+    def _from_bytes(self, value, compression):
+        """When used to wrap bytes in a blob."""
+        if compression == 0:
+            compressed = value
+        elif compression == 1:
+            compressed = zlib.compress(value, 9)
+        elif compression == 2:
+            compressed = bz2.compress(value, 9)
+        else:  # pragma: no cover
+            assert False, "Unknown compression identifier"
+
+        self.data_size = len(value)
+        self.used_size = len(compressed)
+        return compressed
+
+    def _to_file(self, f):
+        """Private friend method called by encoder to write a blob to a file."""
+        # Write sizes - write at least in a size that allows resizing
+        if self.allocated_size <= 250 and self.compression == 0:
+            f.write(spack("<B", self.allocated_size))
+            f.write(spack("<B", self.used_size))
+            f.write(lencode(self.data_size))
+        else:
+            f.write(spack("<BQ", 253, self.allocated_size))
+            f.write(spack("<BQ", 253, self.used_size))
+            f.write(spack("<BQ", 253, self.data_size))
+        # Compression and checksum
+        f.write(spack("B", self.compression))
+        if self.use_checksum:
+            f.write(b"\xff" + hashlib.md5(self.compressed).digest())
+        else:
+            f.write(b"\x00")
+        # Byte alignment (only necessary for uncompressed data)
+        if self.compression == 0:
+            alignment = 8 - (f.tell() + 1) % 8  # +1 for the byte to write
+            f.write(spack("<B", alignment))  # padding for byte alignment
+            f.write(b"\x00" * alignment)
+        else:
+            f.write(spack("<B", 0))
+        # The actual data and extra space
+        f.write(self.compressed)
+        f.write(b"\x00" * (self.allocated_size - self.used_size))
+
+    def _from_file(self, f, allow_seek):
+        """Used when a blob is read by the decoder."""
+        # Read blob header data (5 to 42 bytes)
+        # Size
+        allocated_size = strunpack("<B", f.read(1))[0]
+        if allocated_size == 253:
+            allocated_size = strunpack("<Q", f.read(8))[0]  # noqa
+        used_size = strunpack("<B", f.read(1))[0]
+        if used_size == 253:
+            used_size = strunpack("<Q", f.read(8))[0]  # noqa
+        data_size = strunpack("<B", f.read(1))[0]
+        if data_size == 253:
+            data_size = strunpack("<Q", f.read(8))[0]  # noqa
+        # Compression and checksum
+        compression = strunpack("<B", f.read(1))[0]
+        has_checksum = strunpack("<B", f.read(1))[0]
+        if has_checksum:
+            checksum = f.read(16)
+        # Skip alignment
+        alignment = strunpack("<B", f.read(1))[0]
+        f.read(alignment)
+        # Get or skip data + extra space
+        if allow_seek:
+            self.start_pos = f.tell()
+            self.end_pos = self.start_pos + used_size
+            f.seek(self.start_pos + allocated_size)
+        else:
+            self.start_pos = None
+            self.end_pos = None
+            self.compressed = f.read(used_size)
+            f.read(allocated_size - used_size)
+        # Store info
+        self.alignment = alignment
+        self.compression = compression
+        self.use_checksum = checksum if has_checksum else None
+        self.used_size = used_size
+        self.allocated_size = allocated_size
+        self.data_size = data_size
+
+    def seek(self, p):
+        """Seek to the given position (relative to the blob start)."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot seek in a blob " "that is not created by the BSDF decoder."
+            )
+        if p < 0:
+            p = self.allocated_size + p
+        if p < 0 or p > self.allocated_size:
+            raise IOError("Seek beyond blob boundaries.")
+        self._f.seek(self.start_pos + p)
+
+    def tell(self):
+        """Get the current file pointer position (relative to the blob start)."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot tell in a blob " "that is not created by the BSDF decoder."
+            )
+        return self._f.tell() - self.start_pos
+
+    def write(self, bb):
+        """Write bytes to the blob."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot write in a blob " "that is not created by the BSDF decoder."
+            )
+        if self.compression:
+            raise IOError("Cannot arbitrarily write in compressed blob.")
+        if self._f.tell() + len(bb) > self.end_pos:
+            raise IOError("Write beyond blob boundaries.")
+        self._modified = True
+        return self._f.write(bb)
+
+    def read(self, n):
+        """Read n bytes from the blob."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot read in a blob " "that is not created by the BSDF decoder."
+            )
+        if self.compression:
+            raise IOError("Cannot arbitrarily read in compressed blob.")
+        if self._f.tell() + n > self.end_pos:
+            raise IOError("Read beyond blob boundaries.")
+        return self._f.read(n)
+
+    def get_bytes(self):
+        """Get the contents of the blob as bytes."""
+        if self.compressed is not None:
+            compressed = self.compressed
+        else:
+            i = self._f.tell()
+            self.seek(0)
+            compressed = self._f.read(self.used_size)
+            self._f.seek(i)
+        if self.compression == 0:
+            value = compressed
+        elif self.compression == 1:
+            value = zlib.decompress(compressed)
+        elif self.compression == 2:
+            value = bz2.decompress(compressed)
+        else:  # pragma: no cover
+            raise RuntimeError("Invalid compression %i" % self.compression)
+        return value
+
+    def update_checksum(self):
+        """Reset the blob's checksum if present. Call this after modifying
+        the data.
+        """
+        # or ... should the presence of a checksum mean that data is proteced?
+        if self.use_checksum and self._modified:
+            self.seek(0)
+            compressed = self._f.read(self.used_size)
+            self._f.seek(self.start_pos - self.alignment - 1 - 16)
+            self._f.write(hashlib.md5(compressed).digest())
+
+
+# %% High-level functions
+
+
+def encode(ob, extensions=None, **options):
+    """Save (BSDF-encode) the given object to bytes.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    return s.encode(ob)
+
+
+def save(f, ob, extensions=None, **options):
+    """Save (BSDF-encode) the given object to the given filename or
+    file object. See` BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    if isinstance(f, string_types):
+        with open(f, "wb") as fp:
+            return s.save(fp, ob)
+    else:
+        return s.save(f, ob)
+
+
+def decode(bb, extensions=None, **options):
+    """Load a (BSDF-encoded) structure from bytes.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    return s.decode(bb)
+
+
+def load(f, extensions=None, **options):
+    """Load a (BSDF-encoded) structure from the given filename or file object.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    if isinstance(f, string_types):
+        if f.startswith(("~/", "~\\")):  # pragma: no cover
+            f = os.path.expanduser(f)
+        with open(f, "rb") as fp:
+            return s.load(fp)
+    else:
+        return s.load(f)
+
+
+# Aliases for json compat
+loads = decode
+dumps = encode
+
+
+# %% Standard extensions
+
+# Defining extensions as a dict would be more compact and feel lighter, but
+# that would only allow lambdas, which is too limiting, e.g. for ndarray
+# extension.
+
+
+class Extension(object):
+    """Base class to implement BSDF extensions for special data types.
+
+    Extension classes are provided to the BSDF serializer, which
+    instantiates the class. That way, the extension can be somewhat dynamic:
+    e.g. the NDArrayExtension exposes the ndarray class only when numpy
+    is imported.
+
+    A extension instance must have two attributes. These can be attributes of
+    the class, or of the instance set in ``__init__()``:
+
+    * name (str): the name by which encoded values will be identified.
+    * cls (type): the type (or list of types) to match values with.
+      This is optional, but it makes the encoder select extensions faster.
+
+    Further, it needs 3 methods:
+
+    * `match(serializer, value) -> bool`: return whether the extension can
+      convert the given value. The default is ``isinstance(value, self.cls)``.
+    * `encode(serializer, value) -> encoded_value`: the function to encode a
+      value to more basic data types.
+    * `decode(serializer, encoded_value) -> value`: the function to decode an
+      encoded value back to its intended representation.
+
+    """
+
+    name = ""
+    cls = ()
+
+    def __repr__(self):
+        return "<BSDF extension %r at 0x%s>" % (self.name, hex(id(self)))
+
+    def match(self, s, v):
+        return isinstance(v, self.cls)
+
+    def encode(self, s, v):
+        raise NotImplementedError()
+
+    def decode(self, s, v):
+        raise NotImplementedError()
+
+
+class ComplexExtension(Extension):
+    name = "c"
+    cls = complex
+
+    def encode(self, s, v):
+        return (v.real, v.imag)
+
+    def decode(self, s, v):
+        return complex(v[0], v[1])
+
+
+class NDArrayExtension(Extension):
+    name = "ndarray"
+
+    def __init__(self):
+        if "numpy" in sys.modules:
+            import numpy as np
+
+            self.cls = np.ndarray
+
+    def match(self, s, v):  # pragma: no cover - e.g. work for nd arrays in JS
+        return hasattr(v, "shape") and hasattr(v, "dtype") and hasattr(v, "tobytes")
+
+    def encode(self, s, v):
+        return dict(shape=v.shape, dtype=text_type(v.dtype), data=v.tobytes())
+
+    def decode(self, s, v):
+        try:
+            import numpy as np
+        except ImportError:  # pragma: no cover
+            return v
+        a = np.frombuffer(v["data"], dtype=v["dtype"])
+        a.shape = v["shape"]
+        return a
+
+
+standard_extensions = [ComplexExtension, NDArrayExtension]
+
+
+if __name__ == "__main__":
+    # Invoke CLI
+    import bsdf_cli
+
+    bsdf_cli.main()

minigpt2/lib/python3.10/site-packages/imageio/plugins/_dicom.py

@@ -0,0 +1,932 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Plugin for reading DICOM files.
+"""
+
+# todo: Use pydicom:
+# * Note: is not py3k ready yet
+# * Allow reading the full meta info
+# I think we can more or less replace the SimpleDicomReader with a
+# pydicom.Dataset For series, only ned to read the full info from one
+# file: speed still high
+# * Perhaps allow writing?
+
+import sys
+import os
+import struct
+import logging
+
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+# Determine endianity of system
+sys_is_little_endian = sys.byteorder == "little"
+
+# Define a dictionary that contains the tags that we would like to know
+MINIDICT = {
+    (0x7FE0, 0x0010): ("PixelData", "OB"),
+    # Date and time
+    (0x0008, 0x0020): ("StudyDate", "DA"),
+    (0x0008, 0x0021): ("SeriesDate", "DA"),
+    (0x0008, 0x0022): ("AcquisitionDate", "DA"),
+    (0x0008, 0x0023): ("ContentDate", "DA"),
+    (0x0008, 0x0030): ("StudyTime", "TM"),
+    (0x0008, 0x0031): ("SeriesTime", "TM"),
+    (0x0008, 0x0032): ("AcquisitionTime", "TM"),
+    (0x0008, 0x0033): ("ContentTime", "TM"),
+    # With what, where, by whom?
+    (0x0008, 0x0060): ("Modality", "CS"),
+    (0x0008, 0x0070): ("Manufacturer", "LO"),
+    (0x0008, 0x0080): ("InstitutionName", "LO"),
+    # Descriptions
+    (0x0008, 0x1030): ("StudyDescription", "LO"),
+    (0x0008, 0x103E): ("SeriesDescription", "LO"),
+    # UID's
+    (0x0008, 0x0016): ("SOPClassUID", "UI"),
+    (0x0008, 0x0018): ("SOPInstanceUID", "UI"),
+    (0x0020, 0x000D): ("StudyInstanceUID", "UI"),
+    (0x0020, 0x000E): ("SeriesInstanceUID", "UI"),
+    (0x0008, 0x0117): ("ContextUID", "UI"),
+    # Numbers
+    (0x0020, 0x0011): ("SeriesNumber", "IS"),
+    (0x0020, 0x0012): ("AcquisitionNumber", "IS"),
+    (0x0020, 0x0013): ("InstanceNumber", "IS"),
+    (0x0020, 0x0014): ("IsotopeNumber", "IS"),
+    (0x0020, 0x0015): ("PhaseNumber", "IS"),
+    (0x0020, 0x0016): ("IntervalNumber", "IS"),
+    (0x0020, 0x0017): ("TimeSlotNumber", "IS"),
+    (0x0020, 0x0018): ("AngleNumber", "IS"),
+    (0x0020, 0x0019): ("ItemNumber", "IS"),
+    (0x0020, 0x0020): ("PatientOrientation", "CS"),
+    (0x0020, 0x0030): ("ImagePosition", "CS"),
+    (0x0020, 0x0032): ("ImagePositionPatient", "CS"),
+    (0x0020, 0x0035): ("ImageOrientation", "CS"),
+    (0x0020, 0x0037): ("ImageOrientationPatient", "CS"),
+    # Patient information
+    (0x0010, 0x0010): ("PatientName", "PN"),
+    (0x0010, 0x0020): ("PatientID", "LO"),
+    (0x0010, 0x0030): ("PatientBirthDate", "DA"),
+    (0x0010, 0x0040): ("PatientSex", "CS"),
+    (0x0010, 0x1010): ("PatientAge", "AS"),
+    (0x0010, 0x1020): ("PatientSize", "DS"),
+    (0x0010, 0x1030): ("PatientWeight", "DS"),
+    # Image specific (required to construct numpy array)
+    (0x0028, 0x0002): ("SamplesPerPixel", "US"),
+    (0x0028, 0x0008): ("NumberOfFrames", "IS"),
+    (0x0028, 0x0100): ("BitsAllocated", "US"),
+    (0x0028, 0x0101): ("BitsStored", "US"),
+    (0x0028, 0x0102): ("HighBit", "US"),
+    (0x0028, 0x0103): ("PixelRepresentation", "US"),
+    (0x0028, 0x0010): ("Rows", "US"),
+    (0x0028, 0x0011): ("Columns", "US"),
+    (0x0028, 0x1052): ("RescaleIntercept", "DS"),
+    (0x0028, 0x1053): ("RescaleSlope", "DS"),
+    # Image specific (for the user)
+    (0x0028, 0x0030): ("PixelSpacing", "DS"),
+    (0x0018, 0x0088): ("SliceSpacing", "DS"),
+}
+
+# Define some special tags:
+# See PS 3.5-2008 section 7.5 (p.40)
+ItemTag = (0xFFFE, 0xE000)  # start of Sequence Item
+ItemDelimiterTag = (0xFFFE, 0xE00D)  # end of Sequence Item
+SequenceDelimiterTag = (0xFFFE, 0xE0DD)  # end of Sequence of undefined length
+
+# Define set of groups that we're interested in (so we can quickly skip others)
+GROUPS = set([key[0] for key in MINIDICT.keys()])
+VRS = set([val[1] for val in MINIDICT.values()])
+
+
+class NotADicomFile(Exception):
+    pass
+
+
+class CompressedDicom(RuntimeError):
+    pass
+
+
+class SimpleDicomReader(object):
+    """
+    This class provides reading of pixel data from DICOM files. It is
+    focussed on getting the pixel data, not the meta info.
+
+    To use, first create an instance of this class (giving it
+    a file object or filename). Next use the info attribute to
+    get a dict of the meta data. The loading of pixel data is
+    deferred until get_numpy_array() is called.
+
+    Comparison with Pydicom
+    -----------------------
+
+    This code focusses on getting the pixel data out, which allows some
+    shortcuts, resulting in the code being much smaller.
+
+    Since the processing of data elements is much cheaper (it skips a lot
+    of tags), this code is about 3x faster than pydicom (except for the
+    deflated DICOM files).
+
+    This class does borrow some code (and ideas) from the pydicom
+    project, and (to the best of our knowledge) has the same limitations
+    as pydicom with regard to the type of files that it can handle.
+
+    Limitations
+    -----------
+
+    For more advanced DICOM processing, please check out pydicom.
+
+      * Only a predefined subset of data elements (meta information) is read.
+      * This is a reader; it can not write DICOM files.
+      * (just like pydicom) it can handle none of the compressed DICOM
+        formats except for "Deflated Explicit VR Little Endian"
+        (1.2.840.10008.1.2.1.99).
+
+    """
+
+    def __init__(self, file):
+        # Open file if filename given
+        if isinstance(file, str):
+            self._filename = file
+            self._file = open(file, "rb")
+        else:
+            self._filename = "<unknown file>"
+            self._file = file
+        # Init variable to store position and size of pixel data
+        self._pixel_data_loc = None
+        # The meta header is always explicit and little endian
+        self.is_implicit_VR = False
+        self.is_little_endian = True
+        self._unpackPrefix = "<"
+        # Dict to store data elements of interest in
+        self._info = {}
+        # VR Conversion
+        self._converters = {
+            # Numbers
+            "US": lambda x: self._unpack("H", x),
+            "UL": lambda x: self._unpack("L", x),
+            # Numbers encoded as strings
+            "DS": lambda x: self._splitValues(x, float, "\\"),
+            "IS": lambda x: self._splitValues(x, int, "\\"),
+            # strings
+            "AS": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "DA": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "TM": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "UI": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "LO": lambda x: x.decode("utf-8", "ignore").strip("\x00").rstrip(),
+            "CS": lambda x: self._splitValues(x, float, "\\"),
+            "PN": lambda x: x.decode("utf-8", "ignore").strip("\x00").rstrip(),
+        }
+
+        # Initiate reading
+        self._read()
+
+    @property
+    def info(self):
+        return self._info
+
+    def _splitValues(self, x, type, splitter):
+        s = x.decode("ascii").strip("\x00")
+        try:
+            if splitter in s:
+                return tuple([type(v) for v in s.split(splitter) if v.strip()])
+            else:
+                return type(s)
+        except ValueError:
+            return s
+
+    def _unpack(self, fmt, value):
+        return struct.unpack(self._unpackPrefix + fmt, value)[0]
+
+    # Really only so we need minimal changes to _pixel_data_numpy
+    def __iter__(self):
+        return iter(self._info.keys())
+
+    def __getattr__(self, key):
+        info = object.__getattribute__(self, "_info")
+        if key in info:
+            return info[key]
+        return object.__getattribute__(self, key)  # pragma: no cover
+
+    def _read(self):
+        f = self._file
+        # Check prefix after peamble
+        f.seek(128)
+        if f.read(4) != b"DICM":
+            raise NotADicomFile("Not a valid DICOM file.")
+        # Read
+        self._read_header()
+        self._read_data_elements()
+        self._get_shape_and_sampling()
+        # Close if done, reopen if necessary to read pixel data
+        if os.path.isfile(self._filename):
+            self._file.close()
+            self._file = None
+
+    def _readDataElement(self):
+        f = self._file
+        # Get group  and element
+        group = self._unpack("H", f.read(2))
+        element = self._unpack("H", f.read(2))
+        # Get value length
+        if self.is_implicit_VR:
+            vl = self._unpack("I", f.read(4))
+        else:
+            vr = f.read(2)
+            if vr in (b"OB", b"OW", b"SQ", b"UN"):
+                reserved = f.read(2)  # noqa
+                vl = self._unpack("I", f.read(4))
+            else:
+                vl = self._unpack("H", f.read(2))
+        # Get value
+        if group == 0x7FE0 and element == 0x0010:
+            here = f.tell()
+            self._pixel_data_loc = here, vl
+            f.seek(here + vl)
+            return group, element, b"Deferred loading of pixel data"
+        else:
+            if vl == 0xFFFFFFFF:
+                value = self._read_undefined_length_value()
+            else:
+                value = f.read(vl)
+            return group, element, value
+
+    def _read_undefined_length_value(self, read_size=128):
+        """Copied (in compacted form) from PyDicom
+        Copyright Darcy Mason.
+        """
+        fp = self._file
+        # data_start = fp.tell()
+        search_rewind = 3
+        bytes_to_find = struct.pack(
+            self._unpackPrefix + "HH", SequenceDelimiterTag[0], SequenceDelimiterTag[1]
+        )
+
+        found = False
+        value_chunks = []
+        while not found:
+            chunk_start = fp.tell()
+            bytes_read = fp.read(read_size)
+            if len(bytes_read) < read_size:
+                # try again,
+                # if still don't get required amount, this is last block
+                new_bytes = fp.read(read_size - len(bytes_read))
+                bytes_read += new_bytes
+                if len(bytes_read) < read_size:
+                    raise EOFError(
+                        "End of file reached before sequence " "delimiter found."
+                    )
+            index = bytes_read.find(bytes_to_find)
+            if index != -1:
+                found = True
+                value_chunks.append(bytes_read[:index])
+                fp.seek(chunk_start + index + 4)  # rewind to end of delimiter
+                length = fp.read(4)
+                if length != b"\0\0\0\0":
+                    logger.warning(
+                        "Expected 4 zero bytes after undefined length " "delimiter"
+                    )
+            else:
+                fp.seek(fp.tell() - search_rewind)  # rewind a bit
+                # accumulate the bytes read (not including the rewind)
+                value_chunks.append(bytes_read[:-search_rewind])
+
+        # if get here then have found the byte string
+        return b"".join(value_chunks)
+
+    def _read_header(self):
+        f = self._file
+        TransferSyntaxUID = None
+
+        # Read all elements, store transferSyntax when we encounter it
+        try:
+            while True:
+                fp_save = f.tell()
+                # Get element
+                group, element, value = self._readDataElement()
+                if group == 0x02:
+                    if group == 0x02 and element == 0x10:
+                        TransferSyntaxUID = value.decode("ascii").strip("\x00")
+                else:
+                    # No more group 2: rewind and break
+                    # (don't trust group length)
+                    f.seek(fp_save)
+                    break
+        except (EOFError, struct.error):  # pragma: no cover
+            raise RuntimeError("End of file reached while still in header.")
+
+        # Handle transfer syntax
+        self._info["TransferSyntaxUID"] = TransferSyntaxUID
+        #
+        if TransferSyntaxUID is None:
+            # Assume ExplicitVRLittleEndian
+            is_implicit_VR, is_little_endian = False, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.1":
+            # ExplicitVRLittleEndian
+            is_implicit_VR, is_little_endian = False, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.2":
+            # ExplicitVRBigEndian
+            is_implicit_VR, is_little_endian = False, False
+        elif TransferSyntaxUID == "1.2.840.10008.1.2":
+            # implicit VR little endian
+            is_implicit_VR, is_little_endian = True, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.1.99":
+            # DeflatedExplicitVRLittleEndian:
+            is_implicit_VR, is_little_endian = False, True
+            self._inflate()
+        else:
+            # http://www.dicomlibrary.com/dicom/transfer-syntax/
+            t, extra_info = TransferSyntaxUID, ""
+            if "1.2.840.10008.1.2.4.50" <= t < "1.2.840.10008.1.2.4.99":
+                extra_info = " (JPEG)"
+            if "1.2.840.10008.1.2.4.90" <= t < "1.2.840.10008.1.2.4.99":
+                extra_info = " (JPEG 2000)"
+            if t == "1.2.840.10008.1.2.5":
+                extra_info = " (RLE)"
+            if t == "1.2.840.10008.1.2.6.1":
+                extra_info = " (RFC 2557)"
+            raise CompressedDicom(
+                "The dicom reader can only read files with "
+                "uncompressed image data - not %r%s. You "
+                "can try using dcmtk or gdcm to convert the "
+                "image." % (t, extra_info)
+            )
+
+        # From hereon, use implicit/explicit big/little endian
+        self.is_implicit_VR = is_implicit_VR
+        self.is_little_endian = is_little_endian
+        self._unpackPrefix = "><"[is_little_endian]
+
+    def _read_data_elements(self):
+        info = self._info
+        try:
+            while True:
+                # Get element
+                group, element, value = self._readDataElement()
+                # Is it a group we are interested in?
+                if group in GROUPS:
+                    key = (group, element)
+                    name, vr = MINIDICT.get(key, (None, None))
+                    # Is it an element we are interested in?
+                    if name:
+                        # Store value
+                        converter = self._converters.get(vr, lambda x: x)
+                        info[name] = converter(value)
+        except (EOFError, struct.error):
+            pass  # end of file ...
+
+    def get_numpy_array(self):
+        """Get numpy arra for this DICOM file, with the correct shape,
+        and pixel values scaled appropriately.
+        """
+        # Is there pixel data at all?
+        if "PixelData" not in self:
+            raise TypeError("No pixel data found in this dataset.")
+
+        # Load it now if it was not already loaded
+        if self._pixel_data_loc and len(self.PixelData) < 100:
+            # Reopen file?
+            close_file = False
+            if self._file is None:
+                close_file = True
+                self._file = open(self._filename, "rb")
+            # Read data
+            self._file.seek(self._pixel_data_loc[0])
+            if self._pixel_data_loc[1] == 0xFFFFFFFF:
+                value = self._read_undefined_length_value()
+            else:
+                value = self._file.read(self._pixel_data_loc[1])
+            # Close file
+            if close_file:
+                self._file.close()
+                self._file = None
+            # Overwrite
+            self._info["PixelData"] = value
+
+        # Get data
+        data = self._pixel_data_numpy()
+        data = self._apply_slope_and_offset(data)
+
+        # Remove data again to preserve memory
+        # Note that the data for the original file is loaded twice ...
+        self._info["PixelData"] = (
+            b"Data converted to numpy array, " + b"raw data removed to preserve memory"
+        )
+        return data
+
+    def _get_shape_and_sampling(self):
+        """Get shape and sampling without actuall using the pixel data.
+        In this way, the user can get an idea what's inside without having
+        to load it.
+        """
+        # Get shape (in the same way that pydicom does)
+        if "NumberOfFrames" in self and self.NumberOfFrames > 1:
+            if self.SamplesPerPixel > 1:
+                shape = (
+                    self.SamplesPerPixel,
+                    self.NumberOfFrames,
+                    self.Rows,
+                    self.Columns,
+                )
+            else:
+                shape = self.NumberOfFrames, self.Rows, self.Columns
+        elif "SamplesPerPixel" in self:
+            if self.SamplesPerPixel > 1:
+                if self.BitsAllocated == 8:
+                    shape = self.SamplesPerPixel, self.Rows, self.Columns
+                else:
+                    raise NotImplementedError(
+                        "DICOM plugin only handles "
+                        "SamplesPerPixel > 1 if Bits "
+                        "Allocated = 8"
+                    )
+            else:
+                shape = self.Rows, self.Columns
+        else:
+            raise RuntimeError(
+                "DICOM file has no SamplesPerPixel " "(perhaps this is a report?)"
+            )
+
+        # Try getting sampling between pixels
+        if "PixelSpacing" in self:
+            sampling = float(self.PixelSpacing[0]), float(self.PixelSpacing[1])
+        else:
+            sampling = 1.0, 1.0
+        if "SliceSpacing" in self:
+            sampling = (abs(self.SliceSpacing),) + sampling
+
+        # Ensure that sampling has as many elements as shape
+        sampling = (1.0,) * (len(shape) - len(sampling)) + sampling[-len(shape) :]
+
+        # Set shape and sampling
+        self._info["shape"] = shape
+        self._info["sampling"] = sampling
+
+    def _pixel_data_numpy(self):
+        """Return a NumPy array of the pixel data."""
+        # Taken from pydicom
+        # Copyright (c) 2008-2012 Darcy Mason
+
+        if "PixelData" not in self:
+            raise TypeError("No pixel data found in this dataset.")
+
+        # determine the type used for the array
+        need_byteswap = self.is_little_endian != sys_is_little_endian
+
+        # Make NumPy format code, e.g. "uint16", "int32" etc
+        # from two pieces of info:
+        #    self.PixelRepresentation -- 0 for unsigned, 1 for signed;
+        #    self.BitsAllocated -- 8, 16, or 32
+        format_str = "%sint%d" % (
+            ("u", "")[self.PixelRepresentation],
+            self.BitsAllocated,
+        )
+        try:
+            numpy_format = np.dtype(format_str)
+        except TypeError:  # pragma: no cover
+            raise TypeError(
+                "Data type not understood by NumPy: format='%s', "
+                " PixelRepresentation=%d, BitsAllocated=%d"
+                % (numpy_format, self.PixelRepresentation, self.BitsAllocated)
+            )
+
+        # Have correct Numpy format, so create the NumPy array
+        arr = np.frombuffer(self.PixelData, numpy_format).copy()
+
+        # XXX byte swap - may later handle this in read_file!!?
+        if need_byteswap:
+            arr.byteswap(True)  # True means swap in-place, don't make new copy
+
+        # Note the following reshape operations return a new *view* onto arr,
+        # but don't copy the data
+        arr = arr.reshape(*self._info["shape"])
+        return arr
+
+    def _apply_slope_and_offset(self, data):
+        """
+        If RescaleSlope and RescaleIntercept are present in the data,
+        apply them. The data type of the data is changed if necessary.
+        """
+        # Obtain slope and offset
+        slope, offset = 1, 0
+        needFloats, needApplySlopeOffset = False, False
+        if "RescaleSlope" in self:
+            needApplySlopeOffset = True
+            slope = self.RescaleSlope
+        if "RescaleIntercept" in self:
+            needApplySlopeOffset = True
+            offset = self.RescaleIntercept
+        if int(slope) != slope or int(offset) != offset:
+            needFloats = True
+        if not needFloats:
+            slope, offset = int(slope), int(offset)
+
+        # Apply slope and offset
+        if needApplySlopeOffset:
+            # Maybe we need to change the datatype?
+            if data.dtype in [np.float32, np.float64]:
+                pass
+            elif needFloats:
+                data = data.astype(np.float32)
+            else:
+                # Determine required range
+                minReq, maxReq = data.min().item(), data.max().item()
+                minReq = min([minReq, minReq * slope + offset, maxReq * slope + offset])
+                maxReq = max([maxReq, minReq * slope + offset, maxReq * slope + offset])
+
+                # Determine required datatype from that
+                dtype = None
+                if minReq < 0:
+                    # Signed integer type
+                    maxReq = max([-minReq, maxReq])
+                    if maxReq < 2**7:
+                        dtype = np.int8
+                    elif maxReq < 2**15:
+                        dtype = np.int16
+                    elif maxReq < 2**31:
+                        dtype = np.int32
+                    else:
+                        dtype = np.float32
+                else:
+                    # Unsigned integer type
+                    if maxReq < 2**8:
+                        dtype = np.int8
+                    elif maxReq < 2**16:
+                        dtype = np.int16
+                    elif maxReq < 2**32:
+                        dtype = np.int32
+                    else:
+                        dtype = np.float32
+                # Change datatype
+                if dtype != data.dtype:
+                    data = data.astype(dtype)
+
+            # Apply slope and offset
+            data *= slope
+            data += offset
+
+        # Done
+        return data
+
+    def _inflate(self):
+        # Taken from pydicom
+        # Copyright (c) 2008-2012 Darcy Mason
+        import zlib
+        from io import BytesIO
+
+        # See PS3.6-2008 A.5 (p 71) -- when written, the entire dataset
+        #   following the file metadata was prepared the normal way,
+        #   then "deflate" compression applied.
+        #  All that is needed here is to decompress and then
+        #      use as normal in a file-like object
+        zipped = self._file.read()
+        # -MAX_WBITS part is from comp.lang.python answer:
+        # groups.google.com/group/comp.lang.python/msg/e95b3b38a71e6799
+        unzipped = zlib.decompress(zipped, -zlib.MAX_WBITS)
+        self._file = BytesIO(unzipped)  # a file-like object
+
+
+class DicomSeries(object):
+    """DicomSeries
+    This class represents a serie of dicom files (SimpleDicomReader
+    objects) that belong together. If these are multiple files, they
+    represent the slices of a volume (like for CT or MRI).
+    """
+
+    def __init__(self, suid, progressIndicator):
+        # Init dataset list and the callback
+        self._entries = []
+
+        # Init props
+        self._suid = suid
+        self._info = {}
+        self._progressIndicator = progressIndicator
+
+    def __len__(self):
+        return len(self._entries)
+
+    def __iter__(self):
+        return iter(self._entries)
+
+    def __getitem__(self, index):
+        return self._entries[index]
+
+    @property
+    def suid(self):
+        return self._suid
+
+    @property
+    def shape(self):
+        """The shape of the data (nz, ny, nx)."""
+        return self._info["shape"]
+
+    @property
+    def sampling(self):
+        """The sampling (voxel distances) of the data (dz, dy, dx)."""
+        return self._info["sampling"]
+
+    @property
+    def info(self):
+        """A dictionary containing the information as present in the
+        first dicomfile of this serie. None if there are no entries."""
+        return self._info
+
+    @property
+    def description(self):
+        """A description of the dicom series. Used fields are
+        PatientName, shape of the data, SeriesDescription, and
+        ImageComments.
+        """
+        info = self.info
+
+        # If no info available, return simple description
+        if not info:  # pragma: no cover
+            return "DicomSeries containing %i images" % len(self)
+
+        fields = []
+        # Give patient name
+        if "PatientName" in info:
+            fields.append("" + info["PatientName"])
+        # Also add dimensions
+        if self.shape:
+            tmp = [str(d) for d in self.shape]
+            fields.append("x".join(tmp))
+        # Try adding more fields
+        if "SeriesDescription" in info:
+            fields.append("'" + info["SeriesDescription"] + "'")
+        if "ImageComments" in info:
+            fields.append("'" + info["ImageComments"] + "'")
+
+        # Combine
+        return " ".join(fields)
+
+    def __repr__(self):
+        adr = hex(id(self)).upper()
+        return "<DicomSeries with %i images at %s>" % (len(self), adr)
+
+    def get_numpy_array(self):
+        """Get (load) the data that this DicomSeries represents, and return
+        it as a numpy array. If this serie contains multiple images, the
+        resulting array is 3D, otherwise it's 2D.
+        """
+
+        # It's easy if no file or if just a single file
+        if len(self) == 0:
+            raise ValueError("Serie does not contain any files.")
+        elif len(self) == 1:
+            return self[0].get_numpy_array()
+
+        # Check info
+        if self.info is None:
+            raise RuntimeError("Cannot return volume if series not finished.")
+
+        # Init data (using what the dicom packaged produces as a reference)
+        slice = self[0].get_numpy_array()
+        vol = np.zeros(self.shape, dtype=slice.dtype)
+        vol[0] = slice
+
+        # Fill volume
+        self._progressIndicator.start("loading data", "", len(self))
+        for z in range(1, len(self)):
+            vol[z] = self[z].get_numpy_array()
+            self._progressIndicator.set_progress(z + 1)
+        self._progressIndicator.finish()
+
+        # Done
+        import gc
+
+        gc.collect()
+        return vol
+
+    def _append(self, dcm):
+        self._entries.append(dcm)
+
+    def _sort(self):
+        self._entries.sort(
+            key=lambda k: (
+                k.InstanceNumber,
+                (
+                    k.ImagePositionPatient[2]
+                    if hasattr(k, "ImagePositionPatient")
+                    else None
+                ),
+            )
+        )
+
+    def _finish(self):
+        """
+        Evaluate the series of dicom files. Together they should make up
+        a volumetric dataset. This means the files should meet certain
+        conditions. Also some additional information has to be calculated,
+        such as the distance between the slices. This method sets the
+        attributes for "shape", "sampling" and "info".
+
+        This method checks:
+          * that there are no missing files
+          * that the dimensions of all images match
+          * that the pixel spacing of all images match
+        """
+
+        # The datasets list should be sorted by instance number
+        L = self._entries
+        if len(L) == 0:
+            return
+        elif len(L) == 1:
+            self._info = L[0].info
+            return
+
+        # Get previous
+        ds1 = L[0]
+        # Init measures to calculate average of
+        distance_sum = 0.0
+        # Init measures to check (these are in 2D)
+        dimensions = ds1.Rows, ds1.Columns
+        # sampling = float(ds1.PixelSpacing[0]), float(ds1.PixelSpacing[1])
+        sampling = ds1.info["sampling"][:2]  # row, column
+
+        for index in range(len(L)):
+            # The first round ds1 and ds2 will be the same, for the
+            # distance calculation this does not matter
+            # Get current
+            ds2 = L[index]
+            # Get positions
+            pos1 = float(ds1.ImagePositionPatient[2])
+            pos2 = float(ds2.ImagePositionPatient[2])
+            # Update distance_sum to calculate distance later
+            distance_sum += abs(pos1 - pos2)
+            # Test measures
+            dimensions2 = ds2.Rows, ds2.Columns
+            # sampling2 = float(ds2.PixelSpacing[0]), float(ds2.PixelSpacing[1])
+            sampling2 = ds2.info["sampling"][:2]  # row, column
+            if dimensions != dimensions2:
+                # We cannot produce a volume if the dimensions match
+                raise ValueError("Dimensions of slices does not match.")
+            if sampling != sampling2:
+                # We can still produce a volume, but we should notify the user
+                self._progressIndicator.write("Warn: sampling does not match.")
+            # Store previous
+            ds1 = ds2
+
+        # Finish calculating average distance
+        # (Note that there are len(L)-1 distances)
+        distance_mean = distance_sum / (len(L) - 1)
+
+        # Set info dict
+        self._info = L[0].info.copy()
+
+        # Store information that is specific for the serie
+        self._info["shape"] = (len(L),) + ds2.info["shape"]
+        self._info["sampling"] = (distance_mean,) + ds2.info["sampling"]
+
+
+def list_files(files, path):
+    """List all files in the directory, recursively."""
+    for item in os.listdir(path):
+        item = os.path.join(path, item)
+        if os.path.isdir(item):
+            list_files(files, item)
+        elif os.path.isfile(item):
+            files.append(item)
+
+
+def process_directory(request, progressIndicator, readPixelData=False):
+    """
+    Reads dicom files and returns a list of DicomSeries objects, which
+    contain information about the data, and can be used to load the
+    image or volume data.
+
+    if readPixelData is True, the pixel data of all series is read. By
+    default the loading of pixeldata is deferred until it is requested
+    using the DicomSeries.get_pixel_array() method. In general, both
+    methods should be equally fast.
+    """
+    # Get directory to examine
+    if os.path.isdir(request.filename):
+        path = request.filename
+    elif os.path.isfile(request.filename):
+        path = os.path.dirname(request.filename)
+    else:  # pragma: no cover - tested earlier
+        raise ValueError("Dicom plugin needs a valid filename to examine the directory")
+
+    # Check files
+    files = []
+    list_files(files, path)  # Find files recursively
+
+    # Gather file data and put in DicomSeries
+    series = {}
+    count = 0
+    progressIndicator.start("examining files", "files", len(files))
+    for filename in files:
+        # Show progress (note that we always start with a 0.0)
+        count += 1
+        progressIndicator.set_progress(count)
+        # Skip DICOMDIR files
+        if filename.count("DICOMDIR"):  # pragma: no cover
+            continue
+        # Try loading dicom ...
+        try:
+            dcm = SimpleDicomReader(filename)
+        except NotADicomFile:
+            continue  # skip non-dicom file
+        except Exception as why:  # pragma: no cover
+            progressIndicator.write(str(why))
+            continue
+        # Get SUID and register the file with an existing or new series object
+        try:
+            suid = dcm.SeriesInstanceUID
+        except AttributeError:  # pragma: no cover
+            continue  # some other kind of dicom file
+        if suid not in series:
+            series[suid] = DicomSeries(suid, progressIndicator)
+        series[suid]._append(dcm)
+
+    # Finish progress
+    # progressIndicator.finish('Found %i series.' % len(series))
+
+    # Make a list and sort, so that the order is deterministic
+    series = list(series.values())
+    series.sort(key=lambda x: x.suid)
+
+    # Split series if necessary
+    for serie in reversed([serie for serie in series]):
+        splitSerieIfRequired(serie, series, progressIndicator)
+
+    # Finish all series
+    # progressIndicator.start('analyse series', '', len(series))
+    series_ = []
+    for i in range(len(series)):
+        try:
+            series[i]._finish()
+            series_.append(series[i])
+        except Exception as err:  # pragma: no cover
+            progressIndicator.write(str(err))
+            pass  # Skip serie (probably report-like file without pixels)
+        # progressIndicator.set_progress(i+1)
+    progressIndicator.finish("Found %i correct series." % len(series_))
+
+    # Done
+    return series_
+
+
+def splitSerieIfRequired(serie, series, progressIndicator):
+    """
+    Split the serie in multiple series if this is required. The choice
+    is based on examing the image position relative to the previous
+    image. If it differs too much, it is assumed that there is a new
+    dataset. This can happen for example in unspitted gated CT data.
+    """
+
+    # Sort the original list and get local name
+    serie._sort()
+    L = serie._entries
+    # Init previous slice
+    ds1 = L[0]
+    # Check whether we can do this
+    if "ImagePositionPatient" not in ds1:
+        return
+    # Initialize a list of new lists
+    L2 = [[ds1]]
+    # Init slice distance estimate
+    distance = 0
+
+    for index in range(1, len(L)):
+        # Get current slice
+        ds2 = L[index]
+        # Get positions
+        pos1 = float(ds1.ImagePositionPatient[2])
+        pos2 = float(ds2.ImagePositionPatient[2])
+        # Get distances
+        newDist = abs(pos1 - pos2)
+        # deltaDist = abs(firstPos-pos2)
+        # If the distance deviates more than 2x from what we've seen,
+        # we can agree it's a new dataset.
+        if distance and newDist > 2.1 * distance:
+            L2.append([])
+            distance = 0
+        else:
+            # Test missing file
+            if distance and newDist > 1.5 * distance:
+                progressIndicator.write(
+                    "Warning: missing file after %r" % ds1._filename
+                )
+            distance = newDist
+        # Add to last list
+        L2[-1].append(ds2)
+        # Store previous
+        ds1 = ds2
+
+    # Split if we should
+    if len(L2) > 1:
+        # At what position are we now?
+        i = series.index(serie)
+        # Create new series
+        series2insert = []
+        for L in L2:
+            newSerie = DicomSeries(serie.suid, progressIndicator)
+            newSerie._entries = L
+            series2insert.append(newSerie)
+        # Insert series and remove self
+        for newSerie in reversed(series2insert):
+            series.insert(i, newSerie)
+        series.remove(serie)

minigpt2/lib/python3.10/site-packages/imageio/plugins/_freeimage.py

@@ -0,0 +1,1312 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+# styletest: ignore E261
+
+""" Module imageio/freeimage.py
+
+This module contains the wrapper code for the freeimage library.
+The functions defined in this module are relatively thin; just thin
+enough so that arguments and results are native Python/numpy data
+types.
+
+"""
+
+import os
+import sys
+import ctypes
+import threading
+import logging
+import numpy
+
+from ..core import (
+    get_remote_file,
+    load_lib,
+    Dict,
+    resource_dirs,
+    IS_PYPY,
+    get_platform,
+    InternetNotAllowedError,
+    NeedDownloadError,
+)
+
+logger = logging.getLogger(__name__)
+
+TEST_NUMPY_NO_STRIDES = False  # To test pypy fallback
+
+FNAME_PER_PLATFORM = {
+    "osx32": "libfreeimage-3.16.0-osx10.6.dylib",  # universal library
+    "osx64": "libfreeimage-3.16.0-osx10.6.dylib",
+    "win32": "FreeImage-3.18.0-win32.dll",
+    "win64": "FreeImage-3.18.0-win64.dll",
+    "linux32": "libfreeimage-3.16.0-linux32.so",
+    "linux64": "libfreeimage-3.16.0-linux64.so",
+}
+
+
+def download(directory=None, force_download=False):
+    """Download the FreeImage library to your computer.
+
+    Parameters
+    ----------
+    directory : str | None
+        The directory where the file will be cached if a download was
+        required to obtain the file. By default, the appdata directory
+        is used. This is also the first directory that is checked for
+        a local version of the file.
+    force_download : bool | str
+        If True, the file will be downloaded even if a local copy exists
+        (and this copy will be overwritten). Can also be a YYYY-MM-DD date
+        to ensure a file is up-to-date (modified date of a file on disk,
+        if present, is checked).
+    """
+    plat = get_platform()
+    if plat and plat in FNAME_PER_PLATFORM:
+        fname = "freeimage/" + FNAME_PER_PLATFORM[plat]
+        get_remote_file(fname=fname, directory=directory, force_download=force_download)
+        fi._lib = None  # allow trying again (needed to make tests work)
+
+
+def get_freeimage_lib():
+    """Ensure we have our version of the binary freeimage lib."""
+
+    lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
+    if lib:  # pragma: no cover
+        return lib
+
+    # Get filename to load
+    # If we do not provide a binary, the system may still do ...
+    plat = get_platform()
+    if plat and plat in FNAME_PER_PLATFORM:
+        try:
+            return get_remote_file("freeimage/" + FNAME_PER_PLATFORM[plat], auto=False)
+        except InternetNotAllowedError:
+            pass
+        except NeedDownloadError:
+            raise NeedDownloadError(
+                "Need FreeImage library. "
+                "You can obtain it with either:\n"
+                "  - download using the command: "
+                "imageio_download_bin freeimage\n"
+                "  - download by calling (in Python): "
+                "imageio.plugins.freeimage.download()\n"
+            )
+        except RuntimeError as e:  # pragma: no cover
+            logger.warning(str(e))
+
+
+# Define function to encode a filename to bytes (for the current system)
+def efn(x):
+    return x.encode(sys.getfilesystemencoding())
+
+
+# 4-byte quads of 0,v,v,v from 0,0,0,0 to 0,255,255,255
+GREY_PALETTE = numpy.arange(0, 0x01000000, 0x00010101, dtype=numpy.uint32)
+
+
+class FI_TYPES(object):
+    FIT_UNKNOWN = 0
+    FIT_BITMAP = 1
+    FIT_UINT16 = 2
+    FIT_INT16 = 3
+    FIT_UINT32 = 4
+    FIT_INT32 = 5
+    FIT_FLOAT = 6
+    FIT_DOUBLE = 7
+    FIT_COMPLEX = 8
+    FIT_RGB16 = 9
+    FIT_RGBA16 = 10
+    FIT_RGBF = 11
+    FIT_RGBAF = 12
+
+    dtypes = {
+        FIT_BITMAP: numpy.uint8,
+        FIT_UINT16: numpy.uint16,
+        FIT_INT16: numpy.int16,
+        FIT_UINT32: numpy.uint32,
+        FIT_INT32: numpy.int32,
+        FIT_FLOAT: numpy.float32,
+        FIT_DOUBLE: numpy.float64,
+        FIT_COMPLEX: numpy.complex128,
+        FIT_RGB16: numpy.uint16,
+        FIT_RGBA16: numpy.uint16,
+        FIT_RGBF: numpy.float32,
+        FIT_RGBAF: numpy.float32,
+    }
+
+    fi_types = {
+        (numpy.uint8, 1): FIT_BITMAP,
+        (numpy.uint8, 3): FIT_BITMAP,
+        (numpy.uint8, 4): FIT_BITMAP,
+        (numpy.uint16, 1): FIT_UINT16,
+        (numpy.int16, 1): FIT_INT16,
+        (numpy.uint32, 1): FIT_UINT32,
+        (numpy.int32, 1): FIT_INT32,
+        (numpy.float32, 1): FIT_FLOAT,
+        (numpy.float64, 1): FIT_DOUBLE,
+        (numpy.complex128, 1): FIT_COMPLEX,
+        (numpy.uint16, 3): FIT_RGB16,
+        (numpy.uint16, 4): FIT_RGBA16,
+        (numpy.float32, 3): FIT_RGBF,
+        (numpy.float32, 4): FIT_RGBAF,
+    }
+
+    extra_dims = {
+        FIT_UINT16: [],
+        FIT_INT16: [],
+        FIT_UINT32: [],
+        FIT_INT32: [],
+        FIT_FLOAT: [],
+        FIT_DOUBLE: [],
+        FIT_COMPLEX: [],
+        FIT_RGB16: [3],
+        FIT_RGBA16: [4],
+        FIT_RGBF: [3],
+        FIT_RGBAF: [4],
+    }
+
+
+class IO_FLAGS(object):
+    FIF_LOAD_NOPIXELS = 0x8000  # loading: load the image header only
+    #                          # (not supported by all plugins)
+    BMP_DEFAULT = 0
+    BMP_SAVE_RLE = 1
+    CUT_DEFAULT = 0
+    DDS_DEFAULT = 0
+    EXR_DEFAULT = 0  # save data as half with piz-based wavelet compression
+    EXR_FLOAT = 0x0001  # save data as float instead of half (not recommended)
+    EXR_NONE = 0x0002  # save with no compression
+    EXR_ZIP = 0x0004  # save with zlib compression, in blocks of 16 scan lines
+    EXR_PIZ = 0x0008  # save with piz-based wavelet compression
+    EXR_PXR24 = 0x0010  # save with lossy 24-bit float compression
+    EXR_B44 = 0x0020  # save with lossy 44% float compression
+    #                # - goes to 22% when combined with EXR_LC
+    EXR_LC = 0x0040  # save images with one luminance and two chroma channels,
+    #               # rather than as RGB (lossy compression)
+    FAXG3_DEFAULT = 0
+    GIF_DEFAULT = 0
+    GIF_LOAD256 = 1  # Load the image as a 256 color image with ununsed
+    #               # palette entries, if it's 16 or 2 color
+    GIF_PLAYBACK = 2  # 'Play' the GIF to generate each frame (as 32bpp)
+    #                # instead of returning raw frame data when loading
+    HDR_DEFAULT = 0
+    ICO_DEFAULT = 0
+    ICO_MAKEALPHA = 1  # convert to 32bpp and create an alpha channel from the
+    #                 # AND-mask when loading
+    IFF_DEFAULT = 0
+    J2K_DEFAULT = 0  # save with a 16:1 rate
+    JP2_DEFAULT = 0  # save with a 16:1 rate
+    JPEG_DEFAULT = 0  # loading (see JPEG_FAST);
+    #                # saving (see JPEG_QUALITYGOOD|JPEG_SUBSAMPLING_420)
+    JPEG_FAST = 0x0001  # load the file as fast as possible,
+    #                  # sacrificing some quality
+    JPEG_ACCURATE = 0x0002  # load the file with the best quality,
+    #                      # sacrificing some speed
+    JPEG_CMYK = 0x0004  # load separated CMYK "as is"
+    #                  # (use | to combine with other load flags)
+    JPEG_EXIFROTATE = 0x0008  # load and rotate according to
+    #                        # Exif 'Orientation' tag if available
+    JPEG_QUALITYSUPERB = 0x80  # save with superb quality (100:1)
+    JPEG_QUALITYGOOD = 0x0100  # save with good quality (75:1)
+    JPEG_QUALITYNORMAL = 0x0200  # save with normal quality (50:1)
+    JPEG_QUALITYAVERAGE = 0x0400  # save with average quality (25:1)
+    JPEG_QUALITYBAD = 0x0800  # save with bad quality (10:1)
+    JPEG_PROGRESSIVE = 0x2000  # save as a progressive-JPEG
+    #                         # (use | to combine with other save flags)
+    JPEG_SUBSAMPLING_411 = 0x1000  # save with high 4x1 chroma
+    #                             # subsampling (4:1:1)
+    JPEG_SUBSAMPLING_420 = 0x4000  # save with medium 2x2 medium chroma
+    #                             # subsampling (4:2:0) - default value
+    JPEG_SUBSAMPLING_422 = 0x8000  # save /w low 2x1 chroma subsampling (4:2:2)
+    JPEG_SUBSAMPLING_444 = 0x10000  # save with no chroma subsampling (4:4:4)
+    JPEG_OPTIMIZE = 0x20000  # on saving, compute optimal Huffman coding tables
+    #                       # (can reduce a few percent of file size)
+    JPEG_BASELINE = 0x40000  # save basic JPEG, without metadata or any markers
+    KOALA_DEFAULT = 0
+    LBM_DEFAULT = 0
+    MNG_DEFAULT = 0
+    PCD_DEFAULT = 0
+    PCD_BASE = 1  # load the bitmap sized 768 x 512
+    PCD_BASEDIV4 = 2  # load the bitmap sized 384 x 256
+    PCD_BASEDIV16 = 3  # load the bitmap sized 192 x 128
+    PCX_DEFAULT = 0
+    PFM_DEFAULT = 0
+    PICT_DEFAULT = 0
+    PNG_DEFAULT = 0
+    PNG_IGNOREGAMMA = 1  # loading: avoid gamma correction
+    PNG_Z_BEST_SPEED = 0x0001  # save using ZLib level 1 compression flag
+    #                         # (default value is 6)
+    PNG_Z_DEFAULT_COMPRESSION = 0x0006  # save using ZLib level 6 compression
+    #                                  # flag (default recommended value)
+    PNG_Z_BEST_COMPRESSION = 0x0009  # save using ZLib level 9 compression flag
+    #                               # (default value is 6)
+    PNG_Z_NO_COMPRESSION = 0x0100  # save without ZLib compression
+    PNG_INTERLACED = 0x0200  # save using Adam7 interlacing (use | to combine
+    #                       # with other save flags)
+    PNM_DEFAULT = 0
+    PNM_SAVE_RAW = 0  # Writer saves in RAW format (i.e. P4, P5 or P6)
+    PNM_SAVE_ASCII = 1  # Writer saves in ASCII format (i.e. P1, P2 or P3)
+    PSD_DEFAULT = 0
+    PSD_CMYK = 1  # reads tags for separated CMYK (default is conversion to RGB)
+    PSD_LAB = 2  # reads tags for CIELab (default is conversion to RGB)
+    RAS_DEFAULT = 0
+    RAW_DEFAULT = 0  # load the file as linear RGB 48-bit
+    RAW_PREVIEW = 1  # try to load the embedded JPEG preview with included
+    #               # Exif Data or default to RGB 24-bit
+    RAW_DISPLAY = 2  # load the file as RGB 24-bit
+    SGI_DEFAULT = 0
+    TARGA_DEFAULT = 0
+    TARGA_LOAD_RGB888 = 1  # Convert RGB555 and ARGB8888 -> RGB888.
+    TARGA_SAVE_RLE = 2  # Save with RLE compression
+    TIFF_DEFAULT = 0
+    TIFF_CMYK = 0x0001  # reads/stores tags for separated CMYK
+    #                  # (use | to combine with compression flags)
+    TIFF_PACKBITS = 0x0100  # save using PACKBITS compression
+    TIFF_DEFLATE = 0x0200  # save using DEFLATE (a.k.a. ZLIB) compression
+    TIFF_ADOBE_DEFLATE = 0x0400  # save using ADOBE DEFLATE compression
+    TIFF_NONE = 0x0800  # save without any compression
+    TIFF_CCITTFAX3 = 0x1000  # save using CCITT Group 3 fax encoding
+    TIFF_CCITTFAX4 = 0x2000  # save using CCITT Group 4 fax encoding
+    TIFF_LZW = 0x4000  # save using LZW compression
+    TIFF_JPEG = 0x8000  # save using JPEG compression
+    TIFF_LOGLUV = 0x10000  # save using LogLuv compression
+    WBMP_DEFAULT = 0
+    XBM_DEFAULT = 0
+    XPM_DEFAULT = 0
+
+
+class METADATA_MODELS(object):
+    FIMD_COMMENTS = 0
+    FIMD_EXIF_MAIN = 1
+    FIMD_EXIF_EXIF = 2
+    FIMD_EXIF_GPS = 3
+    FIMD_EXIF_MAKERNOTE = 4
+    FIMD_EXIF_INTEROP = 5
+    FIMD_IPTC = 6
+    FIMD_XMP = 7
+    FIMD_GEOTIFF = 8
+    FIMD_ANIMATION = 9
+
+
+class METADATA_DATATYPE(object):
+    FIDT_BYTE = 1  # 8-bit unsigned integer
+    FIDT_ASCII = 2  # 8-bit bytes w/ last byte null
+    FIDT_SHORT = 3  # 16-bit unsigned integer
+    FIDT_LONG = 4  # 32-bit unsigned integer
+    FIDT_RATIONAL = 5  # 64-bit unsigned fraction
+    FIDT_SBYTE = 6  # 8-bit signed integer
+    FIDT_UNDEFINED = 7  # 8-bit untyped data
+    FIDT_SSHORT = 8  # 16-bit signed integer
+    FIDT_SLONG = 9  # 32-bit signed integer
+    FIDT_SRATIONAL = 10  # 64-bit signed fraction
+    FIDT_FLOAT = 11  # 32-bit IEEE floating point
+    FIDT_DOUBLE = 12  # 64-bit IEEE floating point
+    FIDT_IFD = 13  # 32-bit unsigned integer (offset)
+    FIDT_PALETTE = 14  # 32-bit RGBQUAD
+    FIDT_LONG8 = 16  # 64-bit unsigned integer
+    FIDT_SLONG8 = 17  # 64-bit signed integer
+    FIDT_IFD8 = 18  # 64-bit unsigned integer (offset)
+
+    dtypes = {
+        FIDT_BYTE: numpy.uint8,
+        FIDT_SHORT: numpy.uint16,
+        FIDT_LONG: numpy.uint32,
+        FIDT_RATIONAL: [("numerator", numpy.uint32), ("denominator", numpy.uint32)],
+        FIDT_LONG8: numpy.uint64,
+        FIDT_SLONG8: numpy.int64,
+        FIDT_IFD8: numpy.uint64,
+        FIDT_SBYTE: numpy.int8,
+        FIDT_UNDEFINED: numpy.uint8,
+        FIDT_SSHORT: numpy.int16,
+        FIDT_SLONG: numpy.int32,
+        FIDT_SRATIONAL: [("numerator", numpy.int32), ("denominator", numpy.int32)],
+        FIDT_FLOAT: numpy.float32,
+        FIDT_DOUBLE: numpy.float64,
+        FIDT_IFD: numpy.uint32,
+        FIDT_PALETTE: [
+            ("R", numpy.uint8),
+            ("G", numpy.uint8),
+            ("B", numpy.uint8),
+            ("A", numpy.uint8),
+        ],
+    }
+
+
+class Freeimage(object):
+    """Class to represent an interface to the FreeImage library.
+    This class is relatively thin. It provides a Pythonic API that converts
+    Freeimage objects to Python objects, but that's about it.
+    The actual implementation should be provided by the plugins.
+
+    The recommended way to call into the Freeimage library (so that
+    errors and warnings show up in the right moment) is to use this
+    object as a context manager:
+    with imageio.fi as lib:
+        lib.FreeImage_GetPalette()
+
+    """
+
+    _API = {
+        # All we're doing here is telling ctypes that some of the
+        # FreeImage functions return pointers instead of integers. (On
+        # 64-bit systems, without this information the pointers get
+        # truncated and crashes result). There's no need to list
+        # functions that return ints, or the types of the parameters
+        # to these or other functions -- that's fine to do implicitly.
+        # Note that the ctypes immediately converts the returned void_p
+        # back to a python int again! This is really not helpful,
+        # because then passing it back to another library call will
+        # cause truncation-to-32-bits on 64-bit systems. Thanks, ctypes!
+        # So after these calls one must immediately re-wrap the int as
+        # a c_void_p if it is to be passed back into FreeImage.
+        "FreeImage_AllocateT": (ctypes.c_void_p, None),
+        "FreeImage_FindFirstMetadata": (ctypes.c_void_p, None),
+        "FreeImage_GetBits": (ctypes.c_void_p, None),
+        "FreeImage_GetPalette": (ctypes.c_void_p, None),
+        "FreeImage_GetTagKey": (ctypes.c_char_p, None),
+        "FreeImage_GetTagValue": (ctypes.c_void_p, None),
+        "FreeImage_CreateTag": (ctypes.c_void_p, None),
+        "FreeImage_Save": (ctypes.c_void_p, None),
+        "FreeImage_Load": (ctypes.c_void_p, None),
+        "FreeImage_LoadFromMemory": (ctypes.c_void_p, None),
+        "FreeImage_OpenMultiBitmap": (ctypes.c_void_p, None),
+        "FreeImage_LoadMultiBitmapFromMemory": (ctypes.c_void_p, None),
+        "FreeImage_LockPage": (ctypes.c_void_p, None),
+        "FreeImage_OpenMemory": (ctypes.c_void_p, None),
+        # 'FreeImage_ReadMemory': (ctypes.c_void_p, None),
+        # 'FreeImage_CloseMemory': (ctypes.c_void_p, None),
+        "FreeImage_GetVersion": (ctypes.c_char_p, None),
+        "FreeImage_GetFIFExtensionList": (ctypes.c_char_p, None),
+        "FreeImage_GetFormatFromFIF": (ctypes.c_char_p, None),
+        "FreeImage_GetFIFDescription": (ctypes.c_char_p, None),
+        "FreeImage_ColorQuantizeEx": (ctypes.c_void_p, None),
+        # Pypy wants some extra definitions, so here we go ...
+        "FreeImage_IsLittleEndian": (ctypes.c_int, None),
+        "FreeImage_SetOutputMessage": (ctypes.c_void_p, None),
+        "FreeImage_GetFIFCount": (ctypes.c_int, None),
+        "FreeImage_IsPluginEnabled": (ctypes.c_int, None),
+        "FreeImage_GetFileType": (ctypes.c_int, None),
+        #
+        "FreeImage_GetTagType": (ctypes.c_int, None),
+        "FreeImage_GetTagLength": (ctypes.c_int, None),
+        "FreeImage_FindNextMetadata": (ctypes.c_int, None),
+        "FreeImage_FindCloseMetadata": (ctypes.c_void_p, None),
+        #
+        "FreeImage_GetFIFFromFilename": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsReading": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsWriting": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsExportType": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsExportBPP": (ctypes.c_int, None),
+        "FreeImage_GetHeight": (ctypes.c_int, None),
+        "FreeImage_GetWidth": (ctypes.c_int, None),
+        "FreeImage_GetImageType": (ctypes.c_int, None),
+        "FreeImage_GetBPP": (ctypes.c_int, None),
+        "FreeImage_GetColorsUsed": (ctypes.c_int, None),
+        "FreeImage_ConvertTo32Bits": (ctypes.c_void_p, None),
+        "FreeImage_GetPitch": (ctypes.c_int, None),
+        "FreeImage_Unload": (ctypes.c_void_p, None),
+    }
+
+    def __init__(self):
+        # Initialize freeimage lib as None
+        self._lib = None
+
+        # A lock to create thread-safety
+        self._lock = threading.RLock()
+
+        # Init log messages lists
+        self._messages = []
+
+        # Select functype for error handler
+        if sys.platform.startswith("win"):
+            functype = ctypes.WINFUNCTYPE
+        else:
+            functype = ctypes.CFUNCTYPE
+
+        # Create output message handler
+        @functype(None, ctypes.c_int, ctypes.c_char_p)
+        def error_handler(fif, message):
+            message = message.decode("utf-8")
+            self._messages.append(message)
+            while (len(self._messages)) > 256:
+                self._messages.pop(0)
+
+        # Make sure to keep a ref to function
+        self._error_handler = error_handler
+
+    @property
+    def lib(self):
+        if self._lib is None:
+            try:
+                self.load_freeimage()
+            except OSError as err:
+                self._lib = "The freeimage library could not be loaded: "
+                self._lib += str(err)
+        if isinstance(self._lib, str):
+            raise RuntimeError(self._lib)
+        return self._lib
+
+    def has_lib(self):
+        try:
+            self.lib
+        except Exception:
+            return False
+        return True
+
+    def load_freeimage(self):
+        """Try to load the freeimage lib from the system. If not successful,
+        try to download the imageio version and try again.
+        """
+        # Load library and register API
+        success = False
+        try:
+            # Try without forcing a download, but giving preference
+            # to the imageio-provided lib (if previously downloaded)
+            self._load_freeimage()
+            self._register_api()
+            if self.lib.FreeImage_GetVersion().decode("utf-8") >= "3.15":
+                success = True
+        except OSError:
+            pass
+
+        if not success:
+            # Ensure we have our own lib, try again
+            get_freeimage_lib()
+            self._load_freeimage()
+            self._register_api()
+
+        # Wrap up
+        self.lib.FreeImage_SetOutputMessage(self._error_handler)
+        self.lib_version = self.lib.FreeImage_GetVersion().decode("utf-8")
+
+    def _load_freeimage(self):
+        # Define names
+        lib_names = ["freeimage", "libfreeimage"]
+        exact_lib_names = [
+            "FreeImage",
+            "libfreeimage.dylib",
+            "libfreeimage.so",
+            "libfreeimage.so.3",
+        ]
+        # Add names of libraries that we provide (that file may not exist)
+        res_dirs = resource_dirs()
+        plat = get_platform()
+        if plat:  # Can be None on e.g. FreeBSD
+            fname = FNAME_PER_PLATFORM[plat]
+            for dir in res_dirs:
+                exact_lib_names.insert(0, os.path.join(dir, "freeimage", fname))
+
+        # Add the path specified with IMAGEIO_FREEIMAGE_LIB:
+        lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
+        if lib is not None:
+            exact_lib_names.insert(0, lib)
+
+        # Load
+        try:
+            lib, fname = load_lib(exact_lib_names, lib_names, res_dirs)
+        except OSError as err:  # pragma: no cover
+            err_msg = str(err) + "\nPlease install the FreeImage library."
+            raise OSError(err_msg)
+
+        # Store
+        self._lib = lib
+        self.lib_fname = fname
+
+    def _register_api(self):
+        # Albert's ctypes pattern
+        for f, (restype, argtypes) in self._API.items():
+            func = getattr(self.lib, f)
+            func.restype = restype
+            func.argtypes = argtypes
+
+    # Handling of output messages
+
+    def __enter__(self):
+        self._lock.acquire()
+        return self.lib
+
+    def __exit__(self, *args):
+        self._show_any_warnings()
+        self._lock.release()
+
+    def _reset_log(self):
+        """Reset the list of output messages. Call this before
+        loading or saving an image with the FreeImage API.
+        """
+        self._messages = []
+
+    def _get_error_message(self):
+        """Get the output messages produced since the last reset as
+        one string. Returns 'No known reason.' if there are no messages.
+        Also resets the log.
+        """
+        if self._messages:
+            res = " ".join(self._messages)
+            self._reset_log()
+            return res
+        else:
+            return "No known reason."
+
+    def _show_any_warnings(self):
+        """If there were any messages since the last reset, show them
+        as a warning. Otherwise do nothing. Also resets the messages.
+        """
+        if self._messages:
+            logger.warning("imageio.freeimage warning: " + self._get_error_message())
+            self._reset_log()
+
+    def get_output_log(self):
+        """Return a list of the last 256 output messages
+        (warnings and errors) produced by the FreeImage library.
+        """
+        # This message log is not cleared/reset, but kept to 256 elements.
+        return [m for m in self._messages]
+
+    def getFIF(self, filename, mode, bb=None):
+        """Get the freeimage Format (FIF) from a given filename.
+        If mode is 'r', will try to determine the format by reading
+        the file, otherwise only the filename is used.
+
+        This function also tests whether the format supports reading/writing.
+        """
+        with self as lib:
+            # Init
+            ftype = -1
+            if mode not in "rw":
+                raise ValueError('Invalid mode (must be "r" or "w").')
+
+            # Try getting format from the content. Note that some files
+            # do not have a header that allows reading the format from
+            # the file.
+            if mode == "r":
+                if bb is not None:
+                    fimemory = lib.FreeImage_OpenMemory(ctypes.c_char_p(bb), len(bb))
+                    ftype = lib.FreeImage_GetFileTypeFromMemory(
+                        ctypes.c_void_p(fimemory), len(bb)
+                    )
+                    lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+                if (ftype == -1) and os.path.isfile(filename):
+                    ftype = lib.FreeImage_GetFileType(efn(filename), 0)
+            # Try getting the format from the extension
+            if ftype == -1:
+                ftype = lib.FreeImage_GetFIFFromFilename(efn(filename))
+
+            # Test if ok
+            if ftype == -1:
+                raise ValueError('Cannot determine format of file "%s"' % filename)
+            elif mode == "w" and not lib.FreeImage_FIFSupportsWriting(ftype):
+                raise ValueError('Cannot write the format of file "%s"' % filename)
+            elif mode == "r" and not lib.FreeImage_FIFSupportsReading(ftype):
+                raise ValueError('Cannot read the format of file "%s"' % filename)
+            return ftype
+
+    def create_bitmap(self, filename, ftype, flags=0):
+        """create_bitmap(filename, ftype, flags=0)
+        Create a wrapped bitmap object.
+        """
+        return FIBitmap(self, filename, ftype, flags)
+
+    def create_multipage_bitmap(self, filename, ftype, flags=0):
+        """create_multipage_bitmap(filename, ftype, flags=0)
+        Create a wrapped multipage bitmap object.
+        """
+        return FIMultipageBitmap(self, filename, ftype, flags)
+
+
+class FIBaseBitmap(object):
+    def __init__(self, fi, filename, ftype, flags):
+        self._fi = fi
+        self._filename = filename
+        self._ftype = ftype
+        self._flags = flags
+        self._bitmap = None
+        self._close_funcs = []
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if (self._bitmap is not None) and self._close_funcs:
+            for close_func in self._close_funcs:
+                try:
+                    with self._fi:
+                        fun = close_func[0]
+                        fun(*close_func[1:])
+                except Exception:  # pragma: no cover
+                    pass
+            self._close_funcs = []
+            self._bitmap = None
+
+    def _set_bitmap(self, bitmap, close_func=None):
+        """Function to set the bitmap and specify the function to unload it."""
+        if self._bitmap is not None:
+            pass  # bitmap is converted
+        if close_func is None:
+            close_func = self._fi.lib.FreeImage_Unload, bitmap
+
+        self._bitmap = bitmap
+        if close_func:
+            self._close_funcs.append(close_func)
+
+    def get_meta_data(self):
+        # todo: there is also FreeImage_TagToString, is that useful?
+        # and would that work well when reading and then saving?
+
+        # Create a list of (model_name, number) tuples
+        models = [
+            (name[5:], number)
+            for name, number in METADATA_MODELS.__dict__.items()
+            if name.startswith("FIMD_")
+        ]
+
+        # Prepare
+        metadata = Dict()
+        tag = ctypes.c_void_p()
+
+        with self._fi as lib:
+            # Iterate over all FreeImage meta models
+            for model_name, number in models:
+                # Find beginning, get search handle
+                mdhandle = lib.FreeImage_FindFirstMetadata(
+                    number, self._bitmap, ctypes.byref(tag)
+                )
+                mdhandle = ctypes.c_void_p(mdhandle)
+                if mdhandle:
+                    # Iterate over all tags in this model
+                    more = True
+                    while more:
+                        # Get info about tag
+                        tag_name = lib.FreeImage_GetTagKey(tag).decode("utf-8")
+                        tag_type = lib.FreeImage_GetTagType(tag)
+                        byte_size = lib.FreeImage_GetTagLength(tag)
+                        char_ptr = ctypes.c_char * byte_size
+                        data = char_ptr.from_address(lib.FreeImage_GetTagValue(tag))
+                        # Convert in a way compatible with Pypy
+                        tag_bytes = bytes(bytearray(data))
+                        # The default value is the raw bytes
+                        tag_val = tag_bytes
+                        # Convert to a Python value in the metadata dict
+                        if tag_type == METADATA_DATATYPE.FIDT_ASCII:
+                            tag_val = tag_bytes.decode("utf-8", "replace")
+                        elif tag_type in METADATA_DATATYPE.dtypes:
+                            dtype = METADATA_DATATYPE.dtypes[tag_type]
+                            if IS_PYPY and isinstance(dtype, (list, tuple)):
+                                pass  # pragma: no cover - or we get a segfault
+                            else:
+                                try:
+                                    tag_val = numpy.frombuffer(
+                                        tag_bytes, dtype=dtype
+                                    ).copy()
+                                    if len(tag_val) == 1:
+                                        tag_val = tag_val[0]
+                                except Exception:  # pragma: no cover
+                                    pass
+                        # Store data in dict
+                        subdict = metadata.setdefault(model_name, Dict())
+                        subdict[tag_name] = tag_val
+                        # Next
+                        more = lib.FreeImage_FindNextMetadata(
+                            mdhandle, ctypes.byref(tag)
+                        )
+
+                    # Close search handle for current meta model
+                    lib.FreeImage_FindCloseMetadata(mdhandle)
+
+            # Done
+            return metadata
+
+    def set_meta_data(self, metadata):
+        # Create a dict mapping model_name to number
+        models = {}
+        for name, number in METADATA_MODELS.__dict__.items():
+            if name.startswith("FIMD_"):
+                models[name[5:]] = number
+
+        # Create a mapping from numpy.dtype to METADATA_DATATYPE
+        def get_tag_type_number(dtype):
+            for number, numpy_dtype in METADATA_DATATYPE.dtypes.items():
+                if dtype == numpy_dtype:
+                    return number
+            else:
+                return None
+
+        with self._fi as lib:
+            for model_name, subdict in metadata.items():
+                # Get model number
+                number = models.get(model_name, None)
+                if number is None:
+                    continue  # Unknown model, silent ignore
+
+                for tag_name, tag_val in subdict.items():
+                    # Create new tag
+                    tag = lib.FreeImage_CreateTag()
+                    tag = ctypes.c_void_p(tag)
+
+                    try:
+                        # Convert Python value to FI type, val
+                        is_ascii = False
+                        if isinstance(tag_val, str):
+                            try:
+                                tag_bytes = tag_val.encode("ascii")
+                                is_ascii = True
+                            except UnicodeError:
+                                pass
+                        if is_ascii:
+                            tag_type = METADATA_DATATYPE.FIDT_ASCII
+                            tag_count = len(tag_bytes)
+                        else:
+                            if not hasattr(tag_val, "dtype"):
+                                tag_val = numpy.array([tag_val])
+                            tag_type = get_tag_type_number(tag_val.dtype)
+                            if tag_type is None:
+                                logger.warning(
+                                    "imageio.freeimage warning: Could not "
+                                    "determine tag type of %r." % tag_name
+                                )
+                                continue
+                            tag_bytes = tag_val.tobytes()
+                            tag_count = tag_val.size
+                        # Set properties
+                        lib.FreeImage_SetTagKey(tag, tag_name.encode("utf-8"))
+                        lib.FreeImage_SetTagType(tag, tag_type)
+                        lib.FreeImage_SetTagCount(tag, tag_count)
+                        lib.FreeImage_SetTagLength(tag, len(tag_bytes))
+                        lib.FreeImage_SetTagValue(tag, tag_bytes)
+                        # Store tag
+                        tag_key = lib.FreeImage_GetTagKey(tag)
+                        lib.FreeImage_SetMetadata(number, self._bitmap, tag_key, tag)
+
+                    except Exception as err:  # pragma: no cover
+                        logger.warning(
+                            "imagio.freeimage warning: Could not set tag "
+                            "%r: %s, %s"
+                            % (tag_name, self._fi._get_error_message(), str(err))
+                        )
+                    finally:
+                        lib.FreeImage_DeleteTag(tag)
+
+
+class FIBitmap(FIBaseBitmap):
+    """Wrapper for the FI bitmap object."""
+
+    def allocate(self, array):
+        # Prepare array
+        assert isinstance(array, numpy.ndarray)
+        shape = array.shape
+        dtype = array.dtype
+
+        # Get shape and channel info
+        r, c = shape[:2]
+        if len(shape) == 2:
+            n_channels = 1
+        elif len(shape) == 3:
+            n_channels = shape[2]
+        else:
+            n_channels = shape[0]
+
+        # Get fi_type
+        try:
+            fi_type = FI_TYPES.fi_types[(dtype.type, n_channels)]
+            self._fi_type = fi_type
+        except KeyError:
+            raise ValueError("Cannot write arrays of given type and shape.")
+
+        # Allocate bitmap
+        with self._fi as lib:
+            bpp = 8 * dtype.itemsize * n_channels
+            bitmap = lib.FreeImage_AllocateT(fi_type, c, r, bpp, 0, 0, 0)
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and store
+            if not bitmap:  # pragma: no cover
+                raise RuntimeError(
+                    "Could not allocate bitmap for storage: %s"
+                    % self._fi._get_error_message()
+                )
+            self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    def load_from_filename(self, filename=None):
+        if filename is None:
+            filename = self._filename
+
+        with self._fi as lib:
+            # Create bitmap
+            bitmap = lib.FreeImage_Load(self._ftype, efn(filename), self._flags)
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and store
+            if not bitmap:  # pragma: no cover
+                raise ValueError(
+                    'Could not load bitmap "%s": %s'
+                    % (self._filename, self._fi._get_error_message())
+                )
+            self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    # def load_from_bytes(self, bb):
+    #     with self._fi as lib:
+    #         # Create bitmap
+    #         fimemory = lib.FreeImage_OpenMemory(
+    #                                         ctypes.c_char_p(bb), len(bb))
+    #         bitmap = lib.FreeImage_LoadFromMemory(
+    #                         self._ftype, ctypes.c_void_p(fimemory), self._flags)
+    #         bitmap = ctypes.c_void_p(bitmap)
+    #         lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #
+    #         # Check
+    #         if not bitmap:
+    #             raise ValueError('Could not load bitmap "%s": %s'
+    #                         % (self._filename, self._fi._get_error_message()))
+    #         else:
+    #             self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    def save_to_filename(self, filename=None):
+        if filename is None:
+            filename = self._filename
+
+        ftype = self._ftype
+        bitmap = self._bitmap
+        fi_type = self._fi_type  # element type
+
+        with self._fi as lib:
+            # Check if can write
+            if fi_type == FI_TYPES.FIT_BITMAP:
+                can_write = lib.FreeImage_FIFSupportsExportBPP(
+                    ftype, lib.FreeImage_GetBPP(bitmap)
+                )
+            else:
+                can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
+            if not can_write:
+                raise TypeError("Cannot save image of this format to this file type")
+
+            # Save to file
+            res = lib.FreeImage_Save(ftype, bitmap, efn(filename), self._flags)
+            # Check
+            if res is None:  # pragma: no cover, we do so many checks, this is rare
+                raise RuntimeError(
+                    f"Could not save file `{self._filename}`: {self._fi._get_error_message()}"
+                )
+
+    # def save_to_bytes(self):
+    #     ftype = self._ftype
+    #     bitmap = self._bitmap
+    #     fi_type = self._fi_type # element type
+    #
+    #     with self._fi as lib:
+    #         # Check if can write
+    #         if fi_type == FI_TYPES.FIT_BITMAP:
+    #             can_write = lib.FreeImage_FIFSupportsExportBPP(ftype,
+    #                                     lib.FreeImage_GetBPP(bitmap))
+    #         else:
+    #             can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
+    #         if not can_write:
+    #             raise TypeError('Cannot save image of this format '
+    #                             'to this file type')
+    #
+    #         # Extract the bytes
+    #         fimemory = lib.FreeImage_OpenMemory(0, 0)
+    #         res = lib.FreeImage_SaveToMemory(ftype, bitmap,
+    #                                          ctypes.c_void_p(fimemory),
+    #                                          self._flags)
+    #         if res:
+    #             N = lib.FreeImage_TellMemory(ctypes.c_void_p(fimemory))
+    #             result = ctypes.create_string_buffer(N)
+    #             lib.FreeImage_SeekMemory(ctypes.c_void_p(fimemory), 0)
+    #             lib.FreeImage_ReadMemory(result, 1, N, ctypes.c_void_p(fimemory))
+    #             result = result.raw
+    #         lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #
+    #         # Check
+    #         if not res:
+    #             raise RuntimeError('Could not save file "%s": %s'
+    #                     % (self._filename, self._fi._get_error_message()))
+    #
+    #     # Done
+    #     return result
+
+    def get_image_data(self):
+        dtype, shape, bpp = self._get_type_and_shape()
+        array = self._wrap_bitmap_bits_in_array(shape, dtype, False)
+        with self._fi as lib:
+            isle = lib.FreeImage_IsLittleEndian()
+
+        # swizzle the color components and flip the scanlines to go from
+        # FreeImage's BGR[A] and upside-down internal memory format to
+        # something more normal
+        def n(arr):
+            # return arr[..., ::-1].T  # Does not work on numpypy yet
+            if arr.ndim == 1:  # pragma: no cover
+                return arr[::-1].T
+            elif arr.ndim == 2:  # Always the case here ...
+                return arr[:, ::-1].T
+            elif arr.ndim == 3:  # pragma: no cover
+                return arr[:, :, ::-1].T
+            elif arr.ndim == 4:  # pragma: no cover
+                return arr[:, :, :, ::-1].T
+
+        if len(shape) == 3 and isle and dtype.type == numpy.uint8:
+            b = n(array[0])
+            g = n(array[1])
+            r = n(array[2])
+            if shape[0] == 3:
+                return numpy.dstack((r, g, b))
+            elif shape[0] == 4:
+                a = n(array[3])
+                return numpy.dstack((r, g, b, a))
+            else:  # pragma: no cover - we check this earlier
+                raise ValueError("Cannot handle images of shape %s" % shape)
+
+        # We need to copy because array does *not* own its memory
+        # after bitmap is freed.
+        a = n(array).copy()
+        return a
+
+    def set_image_data(self, array):
+        # Prepare array
+        assert isinstance(array, numpy.ndarray)
+        shape = array.shape
+        dtype = array.dtype
+        with self._fi as lib:
+            isle = lib.FreeImage_IsLittleEndian()
+
+        # Calculate shape and channels
+        r, c = shape[:2]
+        if len(shape) == 2:
+            n_channels = 1
+            w_shape = (c, r)
+        elif len(shape) == 3:
+            n_channels = shape[2]
+            w_shape = (n_channels, c, r)
+        else:
+            n_channels = shape[0]
+
+        def n(arr):  # normalise to freeimage's in-memory format
+            return arr[::-1].T
+
+        wrapped_array = self._wrap_bitmap_bits_in_array(w_shape, dtype, True)
+        # swizzle the color components and flip the scanlines to go to
+        # FreeImage's BGR[A] and upside-down internal memory format
+        # The BGR[A] order is only used for 8bits per channel images
+        # on little endian machines. For everything else RGB[A] is
+        # used.
+        if len(shape) == 3 and isle and dtype.type == numpy.uint8:
+            R = array[:, :, 0]
+            G = array[:, :, 1]
+            B = array[:, :, 2]
+            wrapped_array[0] = n(B)
+            wrapped_array[1] = n(G)
+            wrapped_array[2] = n(R)
+            if shape[2] == 4:
+                A = array[:, :, 3]
+                wrapped_array[3] = n(A)
+        else:
+            wrapped_array[:] = n(array)
+        if self._need_finish:
+            self._finish_wrapped_array(wrapped_array)
+
+        if len(shape) == 2 and dtype.type == numpy.uint8:
+            with self._fi as lib:
+                palette = lib.FreeImage_GetPalette(self._bitmap)
+            palette = ctypes.c_void_p(palette)
+            if not palette:
+                raise RuntimeError("Could not get image palette")
+            try:
+                palette_data = GREY_PALETTE.ctypes.data
+            except Exception:  # pragma: no cover - IS_PYPY
+                palette_data = GREY_PALETTE.__array_interface__["data"][0]
+            ctypes.memmove(palette, palette_data, 1024)
+
+    def _wrap_bitmap_bits_in_array(self, shape, dtype, save):
+        """Return an ndarray view on the data in a FreeImage bitmap. Only
+        valid for as long as the bitmap is loaded (if single page) / locked
+        in memory (if multipage). This is used in loading data, but
+        also during saving, to prepare a strided numpy array buffer.
+
+        """
+        # Get bitmap info
+        with self._fi as lib:
+            pitch = lib.FreeImage_GetPitch(self._bitmap)
+            bits = lib.FreeImage_GetBits(self._bitmap)
+
+        # Get more info
+        height = shape[-1]
+        byte_size = height * pitch
+        itemsize = dtype.itemsize
+
+        # Get strides
+        if len(shape) == 3:
+            strides = (itemsize, shape[0] * itemsize, pitch)
+        else:
+            strides = (itemsize, pitch)
+
+        # Create numpy array and return
+        data = (ctypes.c_char * byte_size).from_address(bits)
+        try:
+            self._need_finish = False
+            if TEST_NUMPY_NO_STRIDES:
+                raise NotImplementedError()
+            return numpy.ndarray(shape, dtype=dtype, buffer=data, strides=strides)
+        except NotImplementedError:
+            # IS_PYPY - not very efficient. We create a C-contiguous
+            # numpy array (because pypy does not support Fortran-order)
+            # and shape it such that the rest of the code can remain.
+            if save:
+                self._need_finish = True  # Flag to use _finish_wrapped_array
+                return numpy.zeros(shape, dtype=dtype)
+            else:
+                bb = bytes(bytearray(data))
+                array = numpy.frombuffer(bb, dtype=dtype).copy()
+                # Deal with strides
+                if len(shape) == 3:
+                    array.shape = shape[2], strides[-1] // shape[0], shape[0]
+                    array2 = array[: shape[2], : shape[1], : shape[0]]
+                    array = numpy.zeros(shape, dtype=array.dtype)
+                    for i in range(shape[0]):
+                        array[i] = array2[:, :, i].T
+                else:
+                    array.shape = shape[1], strides[-1]
+                    array = array[: shape[1], : shape[0]].T
+                return array
+
+    def _finish_wrapped_array(self, array):  # IS_PYPY
+        """Hardcore way to inject numpy array in bitmap."""
+        # Get bitmap info
+        with self._fi as lib:
+            pitch = lib.FreeImage_GetPitch(self._bitmap)
+            bits = lib.FreeImage_GetBits(self._bitmap)
+            bpp = lib.FreeImage_GetBPP(self._bitmap)
+        # Get channels and realwidth
+        nchannels = bpp // 8 // array.itemsize
+        realwidth = pitch // nchannels
+        # Apply padding for pitch if necessary
+        extra = realwidth - array.shape[-2]
+        assert 0 <= extra < 10
+        # Make sort of Fortran, also take padding (i.e. pitch) into account
+        newshape = array.shape[-1], realwidth, nchannels
+        array2 = numpy.zeros(newshape, array.dtype)
+        if nchannels == 1:
+            array2[:, : array.shape[-2], 0] = array.T
+        else:
+            for i in range(nchannels):
+                array2[:, : array.shape[-2], i] = array[i, :, :].T
+        # copy data
+        data_ptr = array2.__array_interface__["data"][0]
+        ctypes.memmove(bits, data_ptr, array2.nbytes)
+        del array2
+
+    def _get_type_and_shape(self):
+        bitmap = self._bitmap
+
+        # Get info on bitmap
+        with self._fi as lib:
+            w = lib.FreeImage_GetWidth(bitmap)
+            h = lib.FreeImage_GetHeight(bitmap)
+            self._fi_type = fi_type = lib.FreeImage_GetImageType(bitmap)
+            if not fi_type:
+                raise ValueError("Unknown image pixel type")
+
+        # Determine required props for numpy array
+        bpp = None
+        dtype = FI_TYPES.dtypes[fi_type]
+
+        if fi_type == FI_TYPES.FIT_BITMAP:
+            with self._fi as lib:
+                bpp = lib.FreeImage_GetBPP(bitmap)
+                has_pallette = lib.FreeImage_GetColorsUsed(bitmap)
+            if has_pallette:
+                # Examine the palette. If it is grayscale, we return as such
+                if has_pallette == 256:
+                    palette = lib.FreeImage_GetPalette(bitmap)
+                    palette = ctypes.c_void_p(palette)
+                    p = (ctypes.c_uint8 * (256 * 4)).from_address(palette.value)
+                    p = numpy.frombuffer(p, numpy.uint32).copy()
+                    if (GREY_PALETTE == p).all():
+                        extra_dims = []
+                        return numpy.dtype(dtype), extra_dims + [w, h], bpp
+                # Convert bitmap and call this method again
+                newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
+                newbitmap = ctypes.c_void_p(newbitmap)
+                self._set_bitmap(newbitmap)
+                return self._get_type_and_shape()
+            elif bpp == 8:
+                extra_dims = []
+            elif bpp == 24:
+                extra_dims = [3]
+            elif bpp == 32:
+                extra_dims = [4]
+            else:  # pragma: no cover
+                # raise ValueError('Cannot convert %d BPP bitmap' % bpp)
+                # Convert bitmap and call this method again
+                newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
+                newbitmap = ctypes.c_void_p(newbitmap)
+                self._set_bitmap(newbitmap)
+                return self._get_type_and_shape()
+        else:
+            extra_dims = FI_TYPES.extra_dims[fi_type]
+
+        # Return dtype and shape
+        return numpy.dtype(dtype), extra_dims + [w, h], bpp
+
+    def quantize(self, quantizer=0, palettesize=256):
+        """Quantize the bitmap to make it 8-bit (paletted). Returns a new
+        FIBitmap object.
+        Only for 24 bit images.
+        """
+        with self._fi as lib:
+            # New bitmap
+            bitmap = lib.FreeImage_ColorQuantizeEx(
+                self._bitmap, quantizer, palettesize, 0, None
+            )
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and return
+            if not bitmap:
+                raise ValueError(
+                    'Could not quantize bitmap "%s": %s'
+                    % (self._filename, self._fi._get_error_message())
+                )
+
+            new = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
+            new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+            new._fi_type = self._fi_type
+            return new
+
+
+# def convert_to_32bit(self):
+#     """ Convert to 32bit image.
+#     """
+#     with self._fi as lib:
+#         # New bitmap
+#         bitmap = lib.FreeImage_ConvertTo32Bits(self._bitmap)
+#         bitmap = ctypes.c_void_p(bitmap)
+#
+#         # Check and return
+#         if not bitmap:
+#             raise ValueError('Could not convert bitmap to 32bit "%s": %s' %
+#                                 (self._filename,
+#                                 self._fi._get_error_message()))
+#         else:
+#             new = FIBitmap(self._fi, self._filename, self._ftype,
+#                             self._flags)
+#             new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+#             new._fi_type = self._fi_type
+#             return new
+
+
+class FIMultipageBitmap(FIBaseBitmap):
+    """Wrapper for the multipage FI bitmap object."""
+
+    def load_from_filename(self, filename=None):
+        if filename is None:  # pragma: no cover
+            filename = self._filename
+
+        # Prepare
+        create_new = False
+        read_only = True
+        keep_cache_in_memory = False
+
+        # Try opening
+        with self._fi as lib:
+            # Create bitmap
+            multibitmap = lib.FreeImage_OpenMultiBitmap(
+                self._ftype,
+                efn(filename),
+                create_new,
+                read_only,
+                keep_cache_in_memory,
+                self._flags,
+            )
+            multibitmap = ctypes.c_void_p(multibitmap)
+
+            # Check
+            if not multibitmap:  # pragma: no cover
+                err = self._fi._get_error_message()
+                raise ValueError(
+                    'Could not open file "%s" as multi-image: %s'
+                    % (self._filename, err)
+                )
+            self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    # def load_from_bytes(self, bb):
+    #     with self._fi as lib:
+    #         # Create bitmap
+    #         fimemory = lib.FreeImage_OpenMemory(
+    #                                         ctypes.c_char_p(bb), len(bb))
+    #         multibitmap = lib.FreeImage_LoadMultiBitmapFromMemory(
+    #             self._ftype, ctypes.c_void_p(fimemory), self._flags)
+    #         multibitmap = ctypes.c_void_p(multibitmap)
+    #         #lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #         self._mem = fimemory
+    #         self._bytes = bb
+    #         # Check
+    #         if not multibitmap:
+    #             raise ValueError('Could not load multibitmap "%s": %s'
+    #                         % (self._filename, self._fi._get_error_message()))
+    #         else:
+    #             self._set_bitmap(multibitmap,
+    #                              (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    def save_to_filename(self, filename=None):
+        if filename is None:  # pragma: no cover
+            filename = self._filename
+
+        # Prepare
+        create_new = True
+        read_only = False
+        keep_cache_in_memory = False
+
+        # Open the file
+        # todo: Set flags at close func
+        with self._fi as lib:
+            multibitmap = lib.FreeImage_OpenMultiBitmap(
+                self._ftype,
+                efn(filename),
+                create_new,
+                read_only,
+                keep_cache_in_memory,
+                0,
+            )
+            multibitmap = ctypes.c_void_p(multibitmap)
+
+            # Check
+            if not multibitmap:  # pragma: no cover
+                msg = 'Could not open file "%s" for writing multi-image: %s' % (
+                    self._filename,
+                    self._fi._get_error_message(),
+                )
+                raise ValueError(msg)
+            self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    def __len__(self):
+        with self._fi as lib:
+            return lib.FreeImage_GetPageCount(self._bitmap)
+
+    def get_page(self, index):
+        """Return the sub-bitmap for the given page index.
+        Please close the returned bitmap when done.
+        """
+        with self._fi as lib:
+            # Create low-level bitmap in freeimage
+            bitmap = lib.FreeImage_LockPage(self._bitmap, index)
+            bitmap = ctypes.c_void_p(bitmap)
+            if not bitmap:  # pragma: no cover
+                raise ValueError(
+                    "Could not open sub-image %i in %r: %s"
+                    % (index, self._filename, self._fi._get_error_message())
+                )
+
+            # Get bitmap object to wrap this bitmap
+            bm = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
+            bm._set_bitmap(
+                bitmap, (lib.FreeImage_UnlockPage, self._bitmap, bitmap, False)
+            )
+            return bm
+
+    def append_bitmap(self, bitmap):
+        """Add a sub-bitmap to the multi-page bitmap."""
+        with self._fi as lib:
+            # no return value
+            lib.FreeImage_AppendPage(self._bitmap, bitmap._bitmap)
+
+
+# Create instance
+fi = Freeimage()

minigpt2/lib/python3.10/site-packages/imageio/plugins/bsdf.py

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write BSDF files.
+
+Backend Library: internal
+
+The BSDF format enables reading and writing of image data in the
+BSDF serialization format. This format allows storage of images, volumes,
+and series thereof. Data can be of any numeric data type, and can
+optionally be compressed. Each image/volume can have associated
+meta data, which can consist of any data type supported by BSDF.
+
+By default, image data is lazily loaded; the actual image data is
+not read until it is requested. This allows storing multiple images
+in a single file and still have fast access to individual images.
+Alternatively, a series of images can be read in streaming mode, reading
+images as they are read (e.g. from http).
+
+BSDF is a simple generic binary format. It is easy to extend and there
+are standard extension definitions for 2D and 3D image data.
+Read more at http://bsdf.io.
+
+
+Parameters
+----------
+random_access : bool
+    Whether individual images in the file can be read in random order.
+    Defaults to True for normal files, and to False when reading from HTTP.
+    If False, the file is read in "streaming mode", allowing reading
+    files as they are read, but without support for "rewinding".
+    Note that setting this to True when reading from HTTP, the whole file
+    is read upon opening it (since lazy loading is not possible over HTTP).
+
+compression : int
+    Use ``0`` or "no" for no compression, ``1`` or "zlib" for Zlib
+    compression (same as zip files and PNG), and ``2`` or "bz2" for Bz2
+    compression (more compact but slower). Default 1 (zlib).
+    Note that some BSDF implementations may not support compression
+    (e.g. JavaScript).
+
+"""
+
+import numpy as np
+
+from ..core import Format
+
+
+def get_bsdf_serializer(options):
+    from . import _bsdf as bsdf
+
+    class NDArrayExtension(bsdf.Extension):
+        """Copy of BSDF's NDArrayExtension but deal with lazy blobs."""
+
+        name = "ndarray"
+        cls = np.ndarray
+
+        def encode(self, s, v):
+            return dict(shape=v.shape, dtype=str(v.dtype), data=v.tobytes())
+
+        def decode(self, s, v):
+            return v  # return as dict, because of lazy blobs, decode in Image
+
+    class ImageExtension(bsdf.Extension):
+        """We implement two extensions that trigger on the Image classes."""
+
+        def encode(self, s, v):
+            return dict(array=v.array, meta=v.meta)
+
+        def decode(self, s, v):
+            return Image(v["array"], v["meta"])
+
+    class Image2DExtension(ImageExtension):
+        name = "image2d"
+        cls = Image2D
+
+    class Image3DExtension(ImageExtension):
+        name = "image3d"
+        cls = Image3D
+
+    exts = [NDArrayExtension, Image2DExtension, Image3DExtension]
+    serializer = bsdf.BsdfSerializer(exts, **options)
+
+    return bsdf, serializer
+
+
+class Image:
+    """Class in which we wrap the array and meta data. By using an extension
+    we can make BSDF trigger on these classes and thus encode the images.
+    as actual images.
+    """
+
+    def __init__(self, array, meta):
+        self.array = array
+        self.meta = meta
+
+    def get_array(self):
+        if not isinstance(self.array, np.ndarray):
+            v = self.array
+            blob = v["data"]
+            if not isinstance(blob, bytes):  # then it's a lazy bsdf.Blob
+                blob = blob.get_bytes()
+            self.array = np.frombuffer(blob, dtype=v["dtype"])
+            self.array.shape = v["shape"]
+        return self.array
+
+    def get_meta(self):
+        return self.meta
+
+
+class Image2D(Image):
+    pass
+
+
+class Image3D(Image):
+    pass
+
+
+class BsdfFormat(Format):
+    """The BSDF format enables reading and writing of image data in the
+    BSDF serialization format. This format allows storage of images, volumes,
+    and series thereof. Data can be of any numeric data type, and can
+    optionally be compressed. Each image/volume can have associated
+    meta data, which can consist of any data type supported by BSDF.
+
+    By default, image data is lazily loaded; the actual image data is
+    not read until it is requested. This allows storing multiple images
+    in a single file and still have fast access to individual images.
+    Alternatively, a series of images can be read in streaming mode, reading
+    images as they are read (e.g. from http).
+
+    BSDF is a simple generic binary format. It is easy to extend and there
+    are standard extension definitions for 2D and 3D image data.
+    Read more at http://bsdf.io.
+
+    Parameters for reading
+    ----------------------
+    random_access : bool
+        Whether individual images in the file can be read in random order.
+        Defaults to True for normal files, and to False when reading from HTTP.
+        If False, the file is read in "streaming mode", allowing reading
+        files as they are read, but without support for "rewinding".
+        Note that setting this to True when reading from HTTP, the whole file
+        is read upon opening it (since lazy loading is not possible over HTTP).
+
+    Parameters for saving
+    ---------------------
+    compression : {0, 1, 2}
+        Use ``0`` or "no" for no compression, ``1`` or "zlib" for Zlib
+        compression (same as zip files and PNG), and ``2`` or "bz2" for Bz2
+        compression (more compact but slower). Default 1 (zlib).
+        Note that some BSDF implementations may not support compression
+        (e.g. JavaScript).
+
+    """
+
+    def _can_read(self, request):
+        if request.mode[1] in (self.modes + "?"):
+            # if request.extension in self.extensions:
+            #     return True
+            if request.firstbytes.startswith(b"BSDF"):
+                return True
+
+    def _can_write(self, request):
+        if request.mode[1] in (self.modes + "?"):
+            if request.extension in self.extensions:
+                return True
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, random_access=None):
+            # Validate - we need a BSDF file consisting of a list of images
+            # The list is typically a stream, but does not have to be.
+            assert self.request.firstbytes[:4] == b"BSDF", "Not a BSDF file"
+            # self.request.firstbytes[5:6] == major and minor version
+            if not (
+                self.request.firstbytes[6:15] == b"M\x07image2D"
+                or self.request.firstbytes[6:15] == b"M\x07image3D"
+                or self.request.firstbytes[6:7] == b"l"
+            ):
+                pass  # Actually, follow a more duck-type approach ...
+                # raise RuntimeError('BSDF file does not look like an '
+                #                   'image container.')
+            # Set options. If we think that seeking is allowed, we lazily load
+            # blobs, and set streaming to False (i.e. the whole file is read,
+            # but we skip over binary blobs), so that we subsequently allow
+            # random access to the images.
+            # If seeking is not allowed (e.g. with a http request), we cannot
+            # lazily load blobs, but we can still load streaming from the web.
+            options = {}
+            if self.request.filename.startswith(("http://", "https://")):
+                ra = False if random_access is None else bool(random_access)
+                options["lazy_blob"] = False  # Because we cannot seek now
+                options["load_streaming"] = not ra  # Load as a stream?
+            else:
+                ra = True if random_access is None else bool(random_access)
+                options["lazy_blob"] = ra  # Don't read data until needed
+                options["load_streaming"] = not ra
+
+            file = self.request.get_file()
+            bsdf, self._serializer = get_bsdf_serializer(options)
+            self._stream = self._serializer.load(file)
+            # Another validation
+            if (
+                isinstance(self._stream, dict)
+                and "meta" in self._stream
+                and "array" in self._stream
+            ):
+                self._stream = Image(self._stream["array"], self._stream["meta"])
+            if not isinstance(self._stream, (Image, list, bsdf.ListStream)):
+                raise RuntimeError(
+                    "BSDF file does not look seem to have an " "image container."
+                )
+
+        def _close(self):
+            pass
+
+        def _get_length(self):
+            if isinstance(self._stream, Image):
+                return 1
+            elif isinstance(self._stream, list):
+                return len(self._stream)
+            elif self._stream.count < 0:
+                return np.inf
+            return self._stream.count
+
+        def _get_data(self, index):
+            # Validate
+            if index < 0 or index >= self.get_length():
+                raise IndexError(
+                    "Image index %i not in [0 %i]." % (index, self.get_length())
+                )
+            # Get Image object
+            if isinstance(self._stream, Image):
+                image_ob = self._stream  # singleton
+            elif isinstance(self._stream, list):
+                # Easy when we have random access
+                image_ob = self._stream[index]
+            else:
+                # For streaming, we need to skip over frames
+                if index < self._stream.index:
+                    raise IndexError(
+                        "BSDF file is being read in streaming "
+                        "mode, thus does not allow rewinding."
+                    )
+                while index > self._stream.index:
+                    self._stream.next()
+                image_ob = self._stream.next()  # Can raise StopIteration
+            # Is this an image?
+            if (
+                isinstance(image_ob, dict)
+                and "meta" in image_ob
+                and "array" in image_ob
+            ):
+                image_ob = Image(image_ob["array"], image_ob["meta"])
+            if isinstance(image_ob, Image):
+                # Return as array (if we have lazy blobs, they are read now)
+                return image_ob.get_array(), image_ob.get_meta()
+            else:
+                r = repr(image_ob)
+                r = r if len(r) < 200 else r[:197] + "..."
+                raise RuntimeError("BSDF file contains non-image " + r)
+
+        def _get_meta_data(self, index):  # pragma: no cover
+            return {}  # This format does not support global meta data
+
+    # -- writer
+
+    class Writer(Format.Writer):
+        def _open(self, compression=1):
+            options = {"compression": compression}
+            bsdf, self._serializer = get_bsdf_serializer(options)
+            if self.request.mode[1] in "iv":
+                self._stream = None  # Singleton image
+                self._written = False
+            else:
+                # Series (stream) of images
+                file = self.request.get_file()
+                self._stream = bsdf.ListStream()
+                self._serializer.save(file, self._stream)
+
+        def _close(self):
+            # We close the stream here, which will mark the number of written
+            # elements. If we would not close it, the file would be fine, it's
+            # just that upon reading it would not be known how many items are
+            # in there.
+            if self._stream is not None:
+                self._stream.close(False)  # False says "keep this a stream"
+
+        def _append_data(self, im, meta):
+            # Determine dimension
+            ndim = None
+            if self.request.mode[1] in "iI":
+                ndim = 2
+            elif self.request.mode[1] in "vV":
+                ndim = 3
+            else:
+                ndim = 3  # Make an educated guess
+                if im.ndim == 2 or (im.ndim == 3 and im.shape[-1] <= 4):
+                    ndim = 2
+            # Validate shape
+            assert ndim in (2, 3)
+            if ndim == 2:
+                assert im.ndim == 2 or (im.ndim == 3 and im.shape[-1] <= 4)
+            else:
+                assert im.ndim == 3 or (im.ndim == 4 and im.shape[-1] <= 4)
+            # Wrap data and meta data in our special class that will trigger
+            # the BSDF image2D or image3D extension.
+            if ndim == 2:
+                ob = Image2D(im, meta)
+            else:
+                ob = Image3D(im, meta)
+            # Write directly or to stream
+            if self._stream is None:
+                assert not self._written, "Cannot write singleton image twice"
+                self._written = True
+                file = self.request.get_file()
+                self._serializer.save(file, ob)
+            else:
+                self._stream.append(ob)
+
+        def set_meta_data(self, meta):  # pragma: no cover
+            raise RuntimeError("The BSDF format only supports " "per-image meta data.")

minigpt2/lib/python3.10/site-packages/imageio/plugins/dicom.py

@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read DICOM files.
+
+Backend Library: internal
+
+A format for reading DICOM images: a common format used to store
+medical image data, such as X-ray, CT and MRI.
+
+This format borrows some code (and ideas) from the pydicom project. However,
+only a predefined subset of tags are extracted from the file. This allows
+for great simplifications allowing us to make a stand-alone reader, and
+also results in a much faster read time.
+
+By default, only uncompressed and deflated transfer syntaxes are supported.
+If gdcm or dcmtk is installed, these will be used to automatically convert
+the data. See https://github.com/malaterre/GDCM/releases for installing GDCM.
+
+This format provides functionality to group images of the same
+series together, thus extracting volumes (and multiple volumes).
+Using volread will attempt to yield a volume. If multiple volumes
+are present, the first one is given. Using mimread will simply yield
+all images in the given directory (not taking series into account).
+
+Parameters
+----------
+progress : {True, False, BaseProgressIndicator}
+    Whether to show progress when reading from multiple files.
+    Default True. By passing an object that inherits from
+    BaseProgressIndicator, the way in which progress is reported
+    can be costumized.
+
+"""
+
+# todo: Use pydicom:
+# * Note: is not py3k ready yet
+# * Allow reading the full meta info
+# I think we can more or less replace the SimpleDicomReader with a
+# pydicom.Dataset For series, only ned to read the full info from one
+# file: speed still high
+# * Perhaps allow writing?
+
+import os
+import sys
+import logging
+import subprocess
+
+from ..core import Format, BaseProgressIndicator, StdoutProgressIndicator
+from ..core import read_n_bytes
+
+_dicom = None  # lazily loaded in load_lib()
+
+logger = logging.getLogger(__name__)
+
+
+def load_lib():
+    global _dicom
+    from . import _dicom
+
+    return _dicom
+
+
+# Determine endianity of system
+sys_is_little_endian = sys.byteorder == "little"
+
+
+def get_dcmdjpeg_exe():
+    fname = "dcmdjpeg" + ".exe" * sys.platform.startswith("win")
+    for dir in (
+        "c:\\dcmtk",
+        "c:\\Program Files",
+        "c:\\Program Files\\dcmtk",
+        "c:\\Program Files (x86)\\dcmtk",
+    ):
+        filename = os.path.join(dir, fname)
+        if os.path.isfile(filename):
+            return [filename]
+
+    try:
+        subprocess.check_call([fname, "--version"])
+        return [fname]
+    except Exception:
+        return None
+
+
+def get_gdcmconv_exe():
+    fname = "gdcmconv" + ".exe" * sys.platform.startswith("win")
+    # Maybe it's on the path
+    try:
+        subprocess.check_call([fname, "--version"])
+        return [fname, "--raw"]
+    except Exception:
+        pass
+    # Select directories where it could be
+    candidates = []
+    base_dirs = [r"c:\Program Files"]
+    for base_dir in base_dirs:
+        if os.path.isdir(base_dir):
+            for dname in os.listdir(base_dir):
+                if dname.lower().startswith("gdcm"):
+                    suffix = dname[4:].strip()
+                    candidates.append((suffix, os.path.join(base_dir, dname)))
+    # Sort, so higher versions are tried earlier
+    candidates.sort(reverse=True)
+    # Select executable
+    filename = None
+    for _, dirname in candidates:
+        exe1 = os.path.join(dirname, "gdcmconv.exe")
+        exe2 = os.path.join(dirname, "bin", "gdcmconv.exe")
+        if os.path.isfile(exe1):
+            filename = exe1
+            break
+        if os.path.isfile(exe2):
+            filename = exe2
+            break
+    else:
+        return None
+    return [filename, "--raw"]
+
+
+class DicomFormat(Format):
+    """See :mod:`imageio.plugins.dicom`"""
+
+    def _can_read(self, request):
+        # If user URI was a directory, we check whether it has a DICOM file
+        if os.path.isdir(request.filename):
+            files = os.listdir(request.filename)
+            for fname in sorted(files):  # Sorting make it consistent
+                filename = os.path.join(request.filename, fname)
+                if os.path.isfile(filename) and "DICOMDIR" not in fname:
+                    with open(filename, "rb") as f:
+                        first_bytes = read_n_bytes(f, 140)
+                    return first_bytes[128:132] == b"DICM"
+            else:
+                return False
+        # Check
+        return request.firstbytes[128:132] == b"DICM"
+
+    def _can_write(self, request):
+        # We cannot save yet. May be possible if we will used pydicom as
+        # a backend.
+        return False
+
+    # --
+
+    class Reader(Format.Reader):
+        _compressed_warning_dirs = set()
+
+        def _open(self, progress=True):
+            if not _dicom:
+                load_lib()
+            if os.path.isdir(self.request.filename):
+                # A dir can be given if the user used the format explicitly
+                self._info = {}
+                self._data = None
+            else:
+                # Read the given dataset now ...
+                try:
+                    dcm = _dicom.SimpleDicomReader(self.request.get_file())
+                except _dicom.CompressedDicom as err:
+                    # We cannot do this on our own. Perhaps with some help ...
+                    cmd = get_gdcmconv_exe()
+                    if not cmd and "JPEG" in str(err):
+                        cmd = get_dcmdjpeg_exe()
+                    if not cmd:
+                        msg = err.args[0].replace("using", "installing")
+                        msg = msg.replace("convert", "auto-convert")
+                        err.args = (msg,)
+                        raise
+                    else:
+                        fname1 = self.request.get_local_filename()
+                        fname2 = fname1 + ".raw"
+                        try:
+                            subprocess.check_call(cmd + [fname1, fname2])
+                        except Exception:
+                            raise err
+                        d = os.path.dirname(fname1)
+                        if d not in self._compressed_warning_dirs:
+                            self._compressed_warning_dirs.add(d)
+                            logger.warning(
+                                "DICOM file contained compressed data. "
+                                + "Autoconverting with "
+                                + cmd[0]
+                                + " (this warning is shown once for each directory)"
+                            )
+                        dcm = _dicom.SimpleDicomReader(fname2)
+
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            # Initialize series, list of DicomSeries objects
+            self._series = None  # only created if needed
+
+            # Set progress indicator
+            if isinstance(progress, BaseProgressIndicator):
+                self._progressIndicator = progress
+            elif progress is True:
+                p = StdoutProgressIndicator("Reading DICOM")
+                self._progressIndicator = p
+            elif progress in (None, False):
+                self._progressIndicator = BaseProgressIndicator("Dummy")
+            else:
+                raise ValueError("Invalid value for progress.")
+
+        def _close(self):
+            # Clean up
+            self._info = None
+            self._data = None
+            self._series = None
+
+        @property
+        def series(self):
+            if self._series is None:
+                pi = self._progressIndicator
+                self._series = _dicom.process_directory(self.request, pi)
+            return self._series
+
+        def _get_length(self):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            if self.request.mode[1] == "i":
+                # User expects one, but lets be honest about this file
+                return nslices
+            elif self.request.mode[1] == "I":
+                # User expects multiple, if this file has multiple slices, ok.
+                # Otherwise we have to check the series.
+                if nslices > 1:
+                    return nslices
+                else:
+                    return sum([len(serie) for serie in self.series])
+            elif self.request.mode[1] == "v":
+                # User expects a volume, if this file has one, ok.
+                # Otherwise we have to check the series
+                if nslices > 1:
+                    return 1
+                else:
+                    return len(self.series)  # We assume one volume per series
+            elif self.request.mode[1] == "V":
+                # User expects multiple volumes. We have to check the series
+                return len(self.series)  # We assume one volume per series
+            else:
+                raise RuntimeError("DICOM plugin should know what to expect.")
+
+        def _get_slice_data(self, index):
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            # Allow index >1 only if this file contains >1
+            if nslices > 1:
+                return self._data[index], self._info
+            elif index == 0:
+                return self._data, self._info
+            else:
+                raise IndexError("Dicom file contains only one slice.")
+
+        def _get_data(self, index):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            if self.request.mode[1] == "i":
+                return self._get_slice_data(index)
+            elif self.request.mode[1] == "I":
+                # Return slice from volume, or return item from series
+                if index == 0 and nslices > 1:
+                    return self._data[index], self._info
+                else:
+                    L = []
+                    for serie in self.series:
+                        L.extend([dcm_ for dcm_ in serie])
+                    return L[index].get_numpy_array(), L[index].info
+            elif self.request.mode[1] in "vV":
+                # Return volume or series
+                if index == 0 and nslices > 1:
+                    return self._data, self._info
+                else:
+                    return (
+                        self.series[index].get_numpy_array(),
+                        self.series[index].info,
+                    )
+            # mode is `?` (typically because we are using V3). If there is a
+            # series (multiple files), index referrs to the element of the
+            # series and we read volumes. If there is no series, index
+            # referrs to the slice in the volume we read "flat" images.
+            elif len(self.series) > 1:
+                # mode is `?` and there are multiple series. Each series is a ndimage.
+                return (
+                    self.series[index].get_numpy_array(),
+                    self.series[index].info,
+                )
+            else:
+                # mode is `?` and there is only one series. Each slice is an ndimage.
+                return self._get_slice_data(index)
+
+        def _get_meta_data(self, index):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            # Default is the meta data of the given file, or the "first" file.
+            if index is None:
+                return self._info
+
+            if self.request.mode[1] == "i":
+                return self._info
+            elif self.request.mode[1] == "I":
+                # Return slice from volume, or return item from series
+                if index == 0 and nslices > 1:
+                    return self._info
+                else:
+                    L = []
+                    for serie in self.series:
+                        L.extend([dcm_ for dcm_ in serie])
+                    return L[index].info
+            elif self.request.mode[1] in "vV":
+                # Return volume or series
+                if index == 0 and nslices > 1:
+                    return self._info
+                else:
+                    return self.series[index].info
+            else:  # pragma: no cover
+                raise ValueError("DICOM plugin should know what to expect.")

minigpt2/lib/python3.10/site-packages/imageio/plugins/feisem.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read TIFF from FEI SEM microscopes.
+
+Backend Library: internal
+
+This format is based on :mod:`TIFF <imageio.plugins.tifffile>`, and supports the
+same parameters. FEI microscopes append metadata as ASCII text at the end of the
+file, which this reader correctly extracts.
+
+Parameters
+----------
+discard_watermark : bool
+    If True (default), discard the bottom rows of the image, which
+    contain no image data, only a watermark with metadata.
+watermark_height : int
+    The height in pixels of the FEI watermark. The default is 70.
+
+See Also
+--------
+    :mod:`imageio.plugins.tifffile`
+
+"""
+
+
+from .tifffile import TiffFormat
+
+
+class FEISEMFormat(TiffFormat):
+    """See :mod:`imageio.plugins.feisem`"""
+
+    def _can_write(self, request):
+        return False  # FEI-SEM only supports reading
+
+    class Reader(TiffFormat.Reader):
+        def _get_data(self, index=0, discard_watermark=True, watermark_height=70):
+            """Get image and metadata from given index.
+
+            FEI images usually (always?) contain a watermark at the
+            bottom of the image, 70 pixels high. We discard this by
+            default as it does not contain any information not present
+            in the metadata.
+            """
+            im, meta = super(FEISEMFormat.Reader, self)._get_data(index)
+            if discard_watermark:
+                im = im[:-watermark_height]
+            return im, meta
+
+        def _get_meta_data(self, index=None):
+            """Read the metadata from an FEI SEM TIFF.
+
+            This metadata is included as ASCII text at the end of the file.
+
+            The index, if provided, is ignored.
+
+            Returns
+            -------
+            metadata : dict
+                Dictionary of metadata.
+            """
+            if hasattr(self, "_fei_meta"):
+                return self._fei_meta
+
+            md = {"root": {}}
+            current_tag = "root"
+            reading_metadata = False
+            filename = self.request.get_local_filename()
+            with open(filename, encoding="utf8", errors="ignore") as fin:
+                for line in fin:
+                    if not reading_metadata:
+                        if not line.startswith("Date="):
+                            continue
+                        else:
+                            reading_metadata = True
+                    line = line.rstrip()
+                    if line.startswith("["):
+                        current_tag = line.lstrip("[").rstrip("]")
+                        md[current_tag] = {}
+                    else:
+                        if "=" in line:  # ignore empty and irrelevant lines
+                            key, val = line.split("=", maxsplit=1)
+                            for tag_type in (int, float):
+                                try:
+                                    val = tag_type(val)
+                                except ValueError:
+                                    continue
+                                else:
+                                    break
+                            md[current_tag][key] = val
+            if not md["root"] and len(md) == 1:
+                raise ValueError("Input file %s contains no FEI metadata." % filename)
+
+            self._fei_meta = md
+            return md

minigpt2/lib/python3.10/site-packages/imageio/plugins/ffmpeg.py

@@ -0,0 +1,729 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read/Write video using FFMPEG
+
+.. note::
+    We are in the process of (slowly) replacing this plugin with a new one that
+    is based on `pyav <https://pyav.org/docs/stable/>`_. It is faster and more
+    flexible than the plugin documented here. Check the :mod:`pyav
+    plugin's documentation <imageio.plugins.pyav>` for more information about
+    this plugin.
+
+Backend Library: https://github.com/imageio/imageio-ffmpeg
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[ffmpeg]
+
+
+The ffmpeg format provides reading and writing for a wide range of movie formats
+such as .avi, .mpeg, .mp4, etc. as well as the ability to read streams from
+webcams and USB cameras. It is based on ffmpeg and is inspired by/based `moviepy
+<https://github.com/Zulko/moviepy/>`_ by Zulko.
+
+Parameters for reading
+----------------------
+fps : scalar
+    The number of frames per second of the input stream. Default None (i.e.
+    read at the file's native fps). One can use this for files with a
+    variable fps, or in cases where imageio is unable to correctly detect
+    the fps. In case of trouble opening camera streams, it may help to set an
+    explicit fps value matching a framerate supported by the camera.
+loop : bool
+    If True, the video will rewind as soon as a frame is requested
+    beyond the last frame. Otherwise, IndexError is raised. Default False.
+    Setting this to True will internally call ``count_frames()``,
+    and set the reader's length to that value instead of inf.
+size : str | tuple
+    The frame size (i.e. resolution) to read the images, e.g.
+    (100, 100) or "640x480". For camera streams, this allows setting
+    the capture resolution. For normal video data, ffmpeg will
+    rescale the data.
+dtype : str | type
+    The dtype for the output arrays. Determines the bit-depth that
+    is requested from ffmpeg. Supported dtypes: uint8, uint16.
+    Default: uint8.
+pixelformat : str
+    The pixel format for the camera to use (e.g. "yuyv422" or
+    "gray"). The camera needs to support the format in order for
+    this to take effect. Note that the images produced by this
+    reader are always RGB.
+input_params : list
+    List additional arguments to ffmpeg for input file options.
+    (Can also be provided as ``ffmpeg_params`` for backwards compatibility)
+    Example ffmpeg arguments to use aggressive error handling:
+    ['-err_detect', 'aggressive']
+output_params : list
+    List additional arguments to ffmpeg for output file options (i.e. the
+    stream being read by imageio).
+print_info : bool
+    Print information about the video file as reported by ffmpeg.
+
+Parameters for writing
+----------------------
+fps : scalar
+    The number of frames per second. Default 10.
+codec : str
+    the video codec to use. Default 'libx264', which represents the
+    widely available mpeg4. Except when saving .wmv files, then the
+    defaults is 'msmpeg4' which is more commonly supported for windows
+quality : float | None
+    Video output quality. Default is 5. Uses variable bit rate. Highest
+    quality is 10, lowest is 0. Set to None to prevent variable bitrate
+    flags to FFMPEG so you can manually specify them using output_params
+    instead. Specifying a fixed bitrate using 'bitrate' disables this
+    parameter.
+bitrate : int | None
+    Set a constant bitrate for the video encoding. Default is None causing
+    'quality' parameter to be used instead.  Better quality videos with
+    smaller file sizes will result from using the 'quality'  variable
+    bitrate parameter rather than specifying a fixed bitrate with this
+    parameter.
+pixelformat: str
+    The output video pixel format. Default is 'yuv420p' which most widely
+    supported by video players.
+input_params : list
+    List additional arguments to ffmpeg for input file options (i.e. the
+    stream that imageio provides).
+output_params : list
+    List additional arguments to ffmpeg for output file options.
+    (Can also be provided as ``ffmpeg_params`` for backwards compatibility)
+    Example ffmpeg arguments to use only intra frames and set aspect ratio:
+    ['-intra', '-aspect', '16:9']
+ffmpeg_log_level: str
+    Sets ffmpeg output log level.  Default is "warning".
+    Values can be "quiet", "panic", "fatal", "error", "warning", "info"
+    "verbose", or "debug". Also prints the FFMPEG command being used by
+    imageio if "info", "verbose", or "debug".
+macro_block_size: int
+    Size constraint for video. Width and height, must be divisible by this
+    number. If not divisible by this number imageio will tell ffmpeg to
+    scale the image up to the next closest size
+    divisible by this number. Most codecs are compatible with a macroblock
+    size of 16 (default), some can go smaller (4, 8). To disable this
+    automatic feature set it to None or 1, however be warned many players
+    can't decode videos that are odd in size and some codecs will produce
+    poor results or fail. See https://en.wikipedia.org/wiki/Macroblock.
+audio_path : str | None
+    Audio path of any audio that needs to be written. Defaults to nothing,
+    so no audio will be written. Please note, when writing shorter video
+    than the original, ffmpeg will not truncate the audio track; it
+    will maintain its original length and be longer than the video.
+audio_codec : str | None
+    The audio codec to use. Defaults to nothing, but if an audio_path has
+    been provided ffmpeg will attempt to set a default codec.
+
+Notes
+-----
+If you are using anaconda and ``anaconda/ffmpeg`` you will not be able to
+encode/decode H.264 (likely due to licensing concerns). If you need this
+format on anaconda install ``conda-forge/ffmpeg`` instead.
+
+You can use the ``IMAGEIO_FFMPEG_EXE`` environment variable to force using a
+specific ffmpeg executable.
+
+To get the number of frames before having read them all, you can use the
+``reader.count_frames()`` method (the reader will then use
+``imageio_ffmpeg.count_frames_and_secs()`` to get the exact number of frames,
+note that this operation can take a few seconds on large files). Alternatively,
+the number of frames can be estimated from the fps and duration in the meta data
+(though these values themselves are not always present/reliable).
+
+"""
+
+import re
+import sys
+import time
+import logging
+import platform
+import threading
+import subprocess as sp
+import imageio_ffmpeg
+
+import numpy as np
+
+from ..core import Format, image_as_uint
+
+logger = logging.getLogger(__name__)
+
+# Get camera format
+if sys.platform.startswith("win"):
+    CAM_FORMAT = "dshow"  # dshow or vfwcap
+elif sys.platform.startswith("linux"):
+    CAM_FORMAT = "video4linux2"
+elif sys.platform.startswith("darwin"):
+    CAM_FORMAT = "avfoundation"
+else:  # pragma: no cover
+    CAM_FORMAT = "unknown-cam-format"
+
+
+def download(directory=None, force_download=False):  # pragma: no cover
+    raise RuntimeError(
+        "imageio.ffmpeg.download() has been deprecated. "
+        "Use 'pip install imageio-ffmpeg' instead.'"
+    )
+
+
+# For backwards compatibility - we dont use this ourselves
+def get_exe():  # pragma: no cover
+    """Wrapper for imageio_ffmpeg.get_ffmpeg_exe()"""
+
+    return imageio_ffmpeg.get_ffmpeg_exe()
+
+
+class FfmpegFormat(Format):
+    """Read/Write ImageResources using FFMPEG.
+
+    See :mod:`imageio.plugins.ffmpeg`
+    """
+
+    def _can_read(self, request):
+        # Read from video stream?
+        # Note that we could write the _video flag here, but a user might
+        # select this format explicitly (and this code is not run)
+        if re.match(r"<video(\d+)>", request.filename):
+            return True
+
+        # Read from file that we know?
+        if request.extension in self.extensions:
+            return True
+
+    def _can_write(self, request):
+        if request.extension in self.extensions:
+            return True
+
+    # --
+
+    class Reader(Format.Reader):
+        _frame_catcher = None
+        _read_gen = None
+
+        def _get_cam_inputname(self, index):
+            if sys.platform.startswith("linux"):
+                return "/dev/" + self.request._video[1:-1]
+
+            elif sys.platform.startswith("win"):
+                # Ask ffmpeg for list of dshow device names
+                ffmpeg_api = imageio_ffmpeg
+                cmd = [
+                    ffmpeg_api.get_ffmpeg_exe(),
+                    "-list_devices",
+                    "true",
+                    "-f",
+                    CAM_FORMAT,
+                    "-i",
+                    "dummy",
+                ]
+                # Set `shell=True` in sp.run to prevent popup of a command
+                # line window in frozen applications. Note: this would be a
+                # security vulnerability if user-input goes into the cmd.
+                # Note that the ffmpeg process returns with exit code 1 when
+                # using `-list_devices` (or `-list_options`), even if the
+                # command is successful, so we set `check=False` explicitly.
+                completed_process = sp.run(
+                    cmd,
+                    stdout=sp.PIPE,
+                    stderr=sp.PIPE,
+                    encoding="utf-8",
+                    shell=True,
+                    check=False,
+                )
+
+                # Return device name at index
+                try:
+                    name = parse_device_names(completed_process.stderr)[index]
+                except IndexError:
+                    raise IndexError("No ffdshow camera at index %i." % index)
+                return "video=%s" % name
+
+            elif sys.platform.startswith("darwin"):
+                # Appears that newer ffmpeg builds don't support -list-devices
+                # on OS X. But you can directly open the camera by index.
+                name = str(index)
+                return name
+
+            else:  # pragma: no cover
+                return "??"
+
+        def _open(
+            self,
+            loop=False,
+            size=None,
+            dtype=None,
+            pixelformat=None,
+            print_info=False,
+            ffmpeg_params=None,
+            input_params=None,
+            output_params=None,
+            fps=None,
+        ):
+            # Get generator functions
+            self._ffmpeg_api = imageio_ffmpeg
+            # Process input args
+            self._arg_loop = bool(loop)
+            if size is None:
+                self._arg_size = None
+            elif isinstance(size, tuple):
+                self._arg_size = "%ix%i" % size
+            elif isinstance(size, str) and "x" in size:
+                self._arg_size = size
+            else:
+                raise ValueError('FFMPEG size must be tuple of "NxM"')
+            if pixelformat is None:
+                pass
+            elif not isinstance(pixelformat, str):
+                raise ValueError("FFMPEG pixelformat must be str")
+            if dtype is None:
+                self._dtype = np.dtype("uint8")
+            else:
+                self._dtype = np.dtype(dtype)
+                allowed_dtypes = ["uint8", "uint16"]
+                if self._dtype.name not in allowed_dtypes:
+                    raise ValueError(
+                        "dtype must be one of: {}".format(", ".join(allowed_dtypes))
+                    )
+            self._arg_pixelformat = pixelformat
+            self._arg_input_params = input_params or []
+            self._arg_output_params = output_params or []
+            self._arg_input_params += ffmpeg_params or []  # backward compat
+            # Write "_video"_arg - indicating webcam support
+            self.request._video = None
+            regex_match = re.match(r"<video(\d+)>", self.request.filename)
+            if regex_match:
+                self.request._video = self.request.filename
+            # Get local filename
+            if self.request._video:
+                index = int(regex_match.group(1))
+                self._filename = self._get_cam_inputname(index)
+            else:
+                self._filename = self.request.get_local_filename()
+                # When passed to ffmpeg on command line, carets need to be escaped.
+                self._filename = self._filename.replace("^", "^^")
+            # Determine pixel format and depth
+            self._depth = 3
+            if self._dtype.name == "uint8":
+                self._pix_fmt = "rgb24"
+                self._bytes_per_channel = 1
+            else:
+                self._pix_fmt = "rgb48le"
+                self._bytes_per_channel = 2
+            # Initialize parameters
+            self._pos = -1
+            self._meta = {"plugin": "ffmpeg"}
+            self._lastread = None
+
+            # Calculating this from fps and duration is not accurate,
+            # and calculating it exactly with ffmpeg_api.count_frames_and_secs
+            # takes too long to do for each video. But we need it for looping.
+            self._nframes = float("inf")
+            if self._arg_loop and not self.request._video:
+                self._nframes = self.count_frames()
+            self._meta["nframes"] = self._nframes
+
+            # Specify input framerate? (only on macOS)
+            # Ideally we'd get the supported framerate from the metadata, but we get the
+            # metadata when we boot ffmpeg ... maybe we could refactor this so we can
+            # get the metadata beforehand, but for now we'll just give it 2 tries on MacOS,
+            # one with fps 30 and one with fps 15.
+            need_input_fps = need_output_fps = False
+            if self.request._video and platform.system().lower() == "darwin":
+                if "-framerate" not in str(self._arg_input_params):
+                    need_input_fps = True
+                if not self.request.kwargs.get("fps", None):
+                    need_output_fps = True
+            if need_input_fps:
+                self._arg_input_params.extend(["-framerate", str(float(30))])
+            if need_output_fps:
+                self._arg_output_params.extend(["-r", str(float(30))])
+
+            # Start ffmpeg subprocess and get meta information
+            try:
+                self._initialize()
+            except IndexError:
+                # Specify input framerate again, this time different.
+                if need_input_fps:
+                    self._arg_input_params[-1] = str(float(15))
+                    self._initialize()
+                else:
+                    raise
+
+            # For cameras, create thread that keeps reading the images
+            if self.request._video:
+                self._frame_catcher = FrameCatcher(self._read_gen)
+
+            # For reference - but disabled, because it is inaccurate
+            # if self._meta["nframes"] == float("inf"):
+            #     if self._meta.get("fps", 0) > 0:
+            #         if self._meta.get("duration", 0) > 0:
+            #             n = round(self._meta["duration"] * self._meta["fps"])
+            #             self._meta["nframes"] = int(n)
+
+        def _close(self):
+            # First close the frame catcher, because we cannot close the gen
+            # if the frame catcher thread is using it
+            if self._frame_catcher is not None:
+                self._frame_catcher.stop_me()
+                self._frame_catcher = None
+            if self._read_gen is not None:
+                self._read_gen.close()
+                self._read_gen = None
+
+        def count_frames(self):
+            """Count the number of frames. Note that this can take a few
+            seconds for large files. Also note that it counts the number
+            of frames in the original video and does not take a given fps
+            into account.
+            """
+            # This would have been nice, but this does not work :(
+            # oargs = []
+            # if self.request.kwargs.get("fps", None):
+            #     fps = float(self.request.kwargs["fps"])
+            #     oargs += ["-r", "%.02f" % fps]
+            cf = self._ffmpeg_api.count_frames_and_secs
+            return cf(self._filename)[0]
+
+        def _get_length(self):
+            return self._nframes  # only not inf if loop is True
+
+        def _get_data(self, index):
+            """Reads a frame at index. Note for coders: getting an
+            arbitrary frame in the video with ffmpeg can be painfully
+            slow if some decoding has to be done. This function tries
+            to avoid fectching arbitrary frames whenever possible, by
+            moving between adjacent frames."""
+            # Modulo index (for looping)
+            if self._arg_loop and self._nframes < float("inf"):
+                index %= self._nframes
+
+            if index == self._pos:
+                return self._lastread, dict(new=False)
+            elif index < 0:
+                raise IndexError("Frame index must be >= 0")
+            elif index >= self._nframes:
+                raise IndexError("Reached end of video")
+            else:
+                if (index < self._pos) or (index > self._pos + 100):
+                    self._initialize(index)
+                else:
+                    self._skip_frames(index - self._pos - 1)
+                result, is_new = self._read_frame()
+                self._pos = index
+                return result, dict(new=is_new)
+
+        def _get_meta_data(self, index):
+            return self._meta
+
+        def _initialize(self, index=0):
+            # Close the current generator, and thereby terminate its subprocess
+            if self._read_gen is not None:
+                self._read_gen.close()
+
+            iargs = []
+            oargs = []
+
+            # Create input args
+            iargs += self._arg_input_params
+            if self.request._video:
+                iargs += ["-f", CAM_FORMAT]
+                if self._arg_pixelformat:
+                    iargs += ["-pix_fmt", self._arg_pixelformat]
+                if self._arg_size:
+                    iargs += ["-s", self._arg_size]
+            elif index > 0:  # re-initialize  / seek
+                # Note: only works if we initialized earlier, and now have meta
+                # Some info here: https://trac.ffmpeg.org/wiki/Seeking
+                # There are two ways to seek, one before -i (input_params) and
+                # after (output_params). The former is fast, because it uses
+                # keyframes, the latter is slow but accurate. According to
+                # the article above, the fast method should also be accurate
+                # from ffmpeg version 2.1, however in version 4.1 our tests
+                # start failing again. Not sure why, but we can solve this
+                # by combining slow and fast. Seek the long stretch using
+                # the fast method, and seek the last 10s the slow way.
+                starttime = index / self._meta["fps"]
+                seek_slow = min(10, starttime)
+                seek_fast = starttime - seek_slow
+                # We used to have this epsilon earlier, when we did not use
+                # the slow seek. I don't think we need it anymore.
+                # epsilon = -1 / self._meta["fps"] * 0.1
+                iargs += ["-ss", "%.06f" % (seek_fast)]
+                oargs += ["-ss", "%.06f" % (seek_slow)]
+
+            # Output args, for writing to pipe
+            if self._arg_size:
+                oargs += ["-s", self._arg_size]
+            if self.request.kwargs.get("fps", None):
+                fps = float(self.request.kwargs["fps"])
+                oargs += ["-r", "%.02f" % fps]
+            oargs += self._arg_output_params
+
+            # Get pixelformat and bytes per pixel
+            pix_fmt = self._pix_fmt
+            bpp = self._depth * self._bytes_per_channel
+
+            # Create generator
+            rf = self._ffmpeg_api.read_frames
+            self._read_gen = rf(
+                self._filename, pix_fmt, bpp, input_params=iargs, output_params=oargs
+            )
+
+            # Read meta data. This start the generator (and ffmpeg subprocess)
+            if self.request._video:
+                # With cameras, catch error and turn into IndexError
+                try:
+                    meta = self._read_gen.__next__()
+                except IOError as err:
+                    err_text = str(err)
+                    if "darwin" in sys.platform:
+                        if "Unknown input format: 'avfoundation'" in err_text:
+                            err_text += (
+                                "Try installing FFMPEG using "
+                                "home brew to get a version with "
+                                "support for cameras."
+                            )
+                    raise IndexError(
+                        "No (working) camera at {}.\n\n{}".format(
+                            self.request._video, err_text
+                        )
+                    )
+                else:
+                    self._meta.update(meta)
+            elif index == 0:
+                self._meta.update(self._read_gen.__next__())
+            else:
+                self._read_gen.__next__()  # we already have meta data
+
+        def _skip_frames(self, n=1):
+            """Reads and throws away n frames"""
+            for i in range(n):
+                self._read_gen.__next__()
+            self._pos += n
+
+        def _read_frame(self):
+            # Read and convert to numpy array
+            w, h = self._meta["size"]
+            framesize = w * h * self._depth * self._bytes_per_channel
+            # t0 = time.time()
+
+            # Read frame
+            if self._frame_catcher:  # pragma: no cover - camera thing
+                s, is_new = self._frame_catcher.get_frame()
+            else:
+                s = self._read_gen.__next__()
+                is_new = True
+
+            # Check
+            if len(s) != framesize:
+                raise RuntimeError(
+                    "Frame is %i bytes, but expected %i." % (len(s), framesize)
+                )
+
+            result = np.frombuffer(s, dtype=self._dtype).copy()
+            result = result.reshape((h, w, self._depth))
+            # t1 = time.time()
+            # print('etime', t1-t0)
+
+            # Store and return
+            self._lastread = result
+            return result, is_new
+
+    # --
+
+    class Writer(Format.Writer):
+        _write_gen = None
+
+        def _open(
+            self,
+            fps=10,
+            codec="libx264",
+            bitrate=None,
+            pixelformat="yuv420p",
+            ffmpeg_params=None,
+            input_params=None,
+            output_params=None,
+            ffmpeg_log_level="quiet",
+            quality=5,
+            macro_block_size=16,
+            audio_path=None,
+            audio_codec=None,
+        ):
+            self._ffmpeg_api = imageio_ffmpeg
+            self._filename = self.request.get_local_filename()
+            self._pix_fmt = None
+            self._depth = None
+            self._size = None
+
+        def _close(self):
+            if self._write_gen is not None:
+                self._write_gen.close()
+                self._write_gen = None
+
+        def _append_data(self, im, meta):
+            # Get props of image
+            h, w = im.shape[:2]
+            size = w, h
+            depth = 1 if im.ndim == 2 else im.shape[2]
+
+            # Ensure that image is in uint8
+            im = image_as_uint(im, bitdepth=8)
+            # To be written efficiently, ie. without creating an immutable
+            # buffer, by calling im.tobytes() the array must be contiguous.
+            if not im.flags.c_contiguous:
+                # checkign the flag is a micro optimization.
+                # the image will be a numpy subclass. See discussion
+                # https://github.com/numpy/numpy/issues/11804
+                im = np.ascontiguousarray(im)
+
+            # Set size and initialize if not initialized yet
+            if self._size is None:
+                map = {1: "gray", 2: "gray8a", 3: "rgb24", 4: "rgba"}
+                self._pix_fmt = map.get(depth, None)
+                if self._pix_fmt is None:
+                    raise ValueError("Image must have 1, 2, 3 or 4 channels")
+                self._size = size
+                self._depth = depth
+                self._initialize()
+
+            # Check size of image
+            if size != self._size:
+                raise ValueError("All images in a movie should have same size")
+            if depth != self._depth:
+                raise ValueError(
+                    "All images in a movie should have same " "number of channels"
+                )
+
+            assert self._write_gen is not None  # Check status
+
+            # Write. Yes, we can send the data in as a numpy array
+            self._write_gen.send(im)
+
+        def set_meta_data(self, meta):
+            raise RuntimeError(
+                "The ffmpeg format does not support setting " "meta data."
+            )
+
+        def _initialize(self):
+            # Close existing generator
+            if self._write_gen is not None:
+                self._write_gen.close()
+
+            # Get parameters
+            # Use None to let imageio-ffmpeg (or ffmpeg) select good results
+            fps = self.request.kwargs.get("fps", 10)
+            codec = self.request.kwargs.get("codec", None)
+            bitrate = self.request.kwargs.get("bitrate", None)
+            quality = self.request.kwargs.get("quality", None)
+            input_params = self.request.kwargs.get("input_params") or []
+            output_params = self.request.kwargs.get("output_params") or []
+            output_params += self.request.kwargs.get("ffmpeg_params") or []
+            pixelformat = self.request.kwargs.get("pixelformat", None)
+            macro_block_size = self.request.kwargs.get("macro_block_size", 16)
+            ffmpeg_log_level = self.request.kwargs.get("ffmpeg_log_level", None)
+            audio_path = self.request.kwargs.get("audio_path", None)
+            audio_codec = self.request.kwargs.get("audio_codec", None)
+
+            macro_block_size = macro_block_size or 1  # None -> 1
+
+            # Create generator
+            self._write_gen = self._ffmpeg_api.write_frames(
+                self._filename,
+                self._size,
+                pix_fmt_in=self._pix_fmt,
+                pix_fmt_out=pixelformat,
+                fps=fps,
+                quality=quality,
+                bitrate=bitrate,
+                codec=codec,
+                macro_block_size=macro_block_size,
+                ffmpeg_log_level=ffmpeg_log_level,
+                input_params=input_params,
+                output_params=output_params,
+                audio_path=audio_path,
+                audio_codec=audio_codec,
+            )
+
+            # Seed the generator (this is where the ffmpeg subprocess starts)
+            self._write_gen.send(None)
+
+
+class FrameCatcher(threading.Thread):
+    """Thread to keep reading the frame data from stdout. This is
+    useful when streaming from a webcam. Otherwise, if the user code
+    does not grab frames fast enough, the buffer will fill up, leading
+    to lag, and ffmpeg can also stall (experienced on Linux). The
+    get_frame() method always returns the last available image.
+    """
+
+    def __init__(self, gen):
+        self._gen = gen
+        self._frame = None
+        self._frame_is_new = False
+        self._lock = threading.RLock()
+        threading.Thread.__init__(self)
+        self.daemon = True  # do not let this thread hold up Python shutdown
+        self._should_stop = False
+        self.start()
+
+    def stop_me(self):
+        self._should_stop = True
+        while self.is_alive():
+            time.sleep(0.001)
+
+    def get_frame(self):
+        while self._frame is None:  # pragma: no cover - an init thing
+            time.sleep(0.001)
+        with self._lock:
+            is_new = self._frame_is_new
+            self._frame_is_new = False  # reset
+            return self._frame, is_new
+
+    def run(self):
+        # This runs in the worker thread
+        try:
+            while not self._should_stop:
+                time.sleep(0)  # give control to other threads
+                frame = self._gen.__next__()
+                with self._lock:
+                    self._frame = frame
+                    self._frame_is_new = True
+        except (StopIteration, EOFError):
+            pass
+
+
+def parse_device_names(ffmpeg_output):
+    """Parse the output of the ffmpeg -list-devices command"""
+    # Collect device names - get [friendly_name, alt_name] of each
+    device_names = []
+    in_video_devices = False
+    for line in ffmpeg_output.splitlines():
+        if line.startswith("[dshow"):
+            logger.debug(line)
+            line = line.split("]", 1)[1].strip()
+            if in_video_devices and line.startswith('"'):
+                friendly_name = line[1:-1]
+                device_names.append([friendly_name, ""])
+            elif in_video_devices and line.lower().startswith("alternative name"):
+                alt_name = line.split(" name ", 1)[1].strip()[1:-1]
+                if sys.platform.startswith("win"):
+                    alt_name = alt_name.replace("&", "^&")  # Tested to work
+                else:
+                    alt_name = alt_name.replace("&", "\\&")  # Does this work?
+                device_names[-1][-1] = alt_name
+            elif "video devices" in line:
+                in_video_devices = True
+            elif "devices" in line:
+                # set False for subsequent "devices" sections
+                in_video_devices = False
+    # Post-process, see #441
+    # prefer friendly names, use alt name if two cams have same friendly name
+    device_names2 = []
+    for friendly_name, alt_name in device_names:
+        if friendly_name not in device_names2:
+            device_names2.append(friendly_name)
+        elif alt_name:
+            device_names2.append(alt_name)
+        else:
+            device_names2.append(friendly_name)  # duplicate, but not much we can do
+    return device_names2

minigpt2/lib/python3.10/site-packages/imageio/plugins/fits.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read FITS files.
+
+Backend Library: `Astropy <https://www.astropy.org/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[fits]
+
+Flexible Image Transport System (FITS) is an open standard defining a
+digital file format useful for storage, transmission and processing of
+scientific and other images. FITS is the most commonly used digital
+file format in astronomy.
+
+
+Parameters
+----------
+cache : bool
+    If the file name is a URL, `~astropy.utils.data.download_file` is used
+    to open the file.  This specifies whether or not to save the file
+    locally in Astropy's download cache (default: `True`).
+uint : bool
+    Interpret signed integer data where ``BZERO`` is the
+    central value and ``BSCALE == 1`` as unsigned integer
+    data.  For example, ``int16`` data with ``BZERO = 32768``
+    and ``BSCALE = 1`` would be treated as ``uint16`` data.
+
+    Note, for backward compatibility, the kwarg **uint16** may
+    be used instead.  The kwarg was renamed when support was
+    added for integers of any size.
+ignore_missing_end : bool
+    Do not issue an exception when opening a file that is
+    missing an ``END`` card in the last header.
+checksum : bool or str
+    If `True`, verifies that both ``DATASUM`` and
+    ``CHECKSUM`` card values (when present in the HDU header)
+    match the header and data of all HDU's in the file.  Updates to a
+    file that already has a checksum will preserve and update the
+    existing checksums unless this argument is given a value of
+    'remove', in which case the CHECKSUM and DATASUM values are not
+    checked, and are removed when saving changes to the file.
+disable_image_compression : bool, optional
+    If `True`, treats compressed image HDU's like normal
+    binary table HDU's.
+do_not_scale_image_data : bool
+    If `True`, image data is not scaled using BSCALE/BZERO values
+    when read.
+ignore_blank : bool
+    If `True`, the BLANK keyword is ignored if present.
+scale_back : bool
+    If `True`, when saving changes to a file that contained scaled
+    image data, restore the data to the original type and reapply the
+    original BSCALE/BZERO values.  This could lead to loss of accuracy
+    if scaling back to integer values after performing floating point
+    operations on the data.
+
+"""
+
+from ..core import Format
+
+_fits = None  # lazily loaded
+
+
+def load_lib():
+    global _fits
+    try:
+        from astropy.io import fits as _fits
+    except ImportError:
+        raise ImportError(
+            "The FITS format relies on the astropy package."
+            "Please refer to http://www.astropy.org/ "
+            "for further instructions."
+        )
+    return _fits
+
+
+class FitsFormat(Format):
+    """See :mod:`imageio.plugins.fits`"""
+
+    def _can_read(self, request):
+        # We return True if ext matches, because this is the only plugin
+        # that can. If astropy is not installed, a useful error follows.
+        return request.extension in self.extensions
+
+    def _can_write(self, request):
+        # No write support
+        return False
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, cache=False, **kwargs):
+            if not _fits:
+                load_lib()
+            hdulist = _fits.open(self.request.get_file(), cache=cache, **kwargs)
+
+            self._index = []
+            allowed_hdu_types = (_fits.ImageHDU, _fits.PrimaryHDU, _fits.CompImageHDU)
+            for n, hdu in zip(range(len(hdulist)), hdulist):
+                if isinstance(hdu, allowed_hdu_types):
+                    # Ignore (primary) header units with no data (use '.size'
+                    # rather than '.data' to avoid actually loading the image):
+                    if hdu.size > 0:
+                        self._index.append(n)
+            self._hdulist = hdulist
+
+        def _close(self):
+            self._hdulist.close()
+
+        def _get_length(self):
+            return len(self._index)
+
+        def _get_data(self, index):
+            # Get data
+            if index < 0 or index >= len(self._index):
+                raise IndexError("Index out of range while reading from fits")
+            im = self._hdulist[self._index[index]].data
+            # Return array and empty meta data
+            return im, {}
+
+        def _get_meta_data(self, index):
+            # Get the meta data for the given index
+            raise RuntimeError("The fits format does not support meta data.")

minigpt2/lib/python3.10/site-packages/imageio/plugins/freeimage.py

@@ -0,0 +1,404 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read/Write images using FreeImage.
+
+Backend Library: `FreeImage <https://freeimage.sourceforge.io/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        imageio_download_bin freeimage
+
+    or you can download the backend using the function::
+
+        imageio.plugins.freeimage.download()
+
+Each Freeimage format has the ``flags`` keyword argument. See the `Freeimage
+documentation <https://freeimage.sourceforge.io/>`_ for more information.
+
+Parameters
+----------
+flags : int
+    A freeimage-specific option. In most cases we provide explicit
+    parameters for influencing image reading.
+
+"""
+
+import numpy as np
+
+from ..core import Format, image_as_uint
+from ..core.request import RETURN_BYTES
+from ._freeimage import FNAME_PER_PLATFORM, IO_FLAGS, download, fi  # noqa
+
+# todo: support files with only meta data
+
+
+class FreeimageFormat(Format):
+    """See :mod:`imageio.plugins.freeimage`"""
+
+    _modes = "i"
+
+    def __init__(self, name, description, extensions=None, modes=None, *, fif=None):
+        super().__init__(name, description, extensions=extensions, modes=modes)
+        self._fif = fif
+
+    @property
+    def fif(self):
+        return self._fif  # Set when format is created
+
+    def _can_read(self, request):
+        # Ask freeimage if it can read it, maybe ext missing
+        if fi.has_lib():
+            if not hasattr(request, "_fif"):
+                try:
+                    request._fif = fi.getFIF(request.filename, "r", request.firstbytes)
+                except Exception:  # pragma: no cover
+                    request._fif = -1
+            if request._fif == self.fif:
+                return True
+            elif request._fif == 7 and self.fif == 14:
+                # PPM gets identified as PBM and PPM can read PBM
+                # see: https://github.com/imageio/imageio/issues/677
+                return True
+
+    def _can_write(self, request):
+        # Ask freeimage, because we are not aware of all formats
+        if fi.has_lib():
+            if not hasattr(request, "_fif"):
+                try:
+                    request._fif = fi.getFIF(request.filename, "w")
+                except ValueError:  # pragma: no cover
+                    if request.raw_uri == RETURN_BYTES:
+                        request._fif = self.fif
+                    else:
+                        request._fif = -1
+            if request._fif is self.fif:
+                return True
+
+    # --
+
+    class Reader(Format.Reader):
+        def _get_length(self):
+            return 1
+
+        def _open(self, flags=0):
+            self._bm = fi.create_bitmap(self.request.filename, self.format.fif, flags)
+            self._bm.load_from_filename(self.request.get_local_filename())
+
+        def _close(self):
+            self._bm.close()
+
+        def _get_data(self, index):
+            if index != 0:
+                raise IndexError("This format only supports singleton images.")
+            return self._bm.get_image_data(), self._bm.get_meta_data()
+
+        def _get_meta_data(self, index):
+            if not (index is None or index == 0):
+                raise IndexError()
+            return self._bm.get_meta_data()
+
+    # --
+
+    class Writer(Format.Writer):
+        def _open(self, flags=0):
+            self._flags = flags  # Store flags for later use
+            self._bm = None
+            self._is_set = False  # To prevent appending more than one image
+            self._meta = {}
+
+        def _close(self):
+            # Set global meta data
+            self._bm.set_meta_data(self._meta)
+            # Write and close
+            self._bm.save_to_filename(self.request.get_local_filename())
+            self._bm.close()
+
+        def _append_data(self, im, meta):
+            # Check if set
+            if not self._is_set:
+                self._is_set = True
+            else:
+                raise RuntimeError(
+                    "Singleton image; " "can only append image data once."
+                )
+            # Pop unit dimension for grayscale images
+            if im.ndim == 3 and im.shape[-1] == 1:
+                im = im[:, :, 0]
+            # Lazy instantaion of the bitmap, we need image data
+            if self._bm is None:
+                self._bm = fi.create_bitmap(
+                    self.request.filename, self.format.fif, self._flags
+                )
+                self._bm.allocate(im)
+            # Set data
+            self._bm.set_image_data(im)
+            # There is no distinction between global and per-image meta data
+            # for singleton images
+            self._meta = meta
+
+        def _set_meta_data(self, meta):
+            self._meta = meta
+
+
+# Special plugins
+
+# todo: there is also FIF_LOAD_NOPIXELS,
+# but perhaps that should be used with get_meta_data.
+
+
+class FreeimageBmpFormat(FreeimageFormat):
+    """A BMP format based on the Freeimage library.
+
+    This format supports grayscale, RGB and RGBA images.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    not available on the system, it can be downloaded manually from
+    <https://github.com/imageio/imageio-binaries> by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for saving
+    ---------------------
+    compression : bool
+        Whether to compress the bitmap using RLE when saving. Default False.
+        It seems this does not always work, but who cares, you should use
+        PNG anyway.
+
+    """
+
+    class Writer(FreeimageFormat.Writer):
+        def _open(self, flags=0, compression=False):
+            # Build flags from kwargs
+            flags = int(flags)
+            if compression:
+                flags |= IO_FLAGS.BMP_SAVE_RLE
+            else:
+                flags |= IO_FLAGS.BMP_DEFAULT
+            # Act as usual, but with modified flags
+            return FreeimageFormat.Writer._open(self, flags)
+
+        def _append_data(self, im, meta):
+            im = image_as_uint(im, bitdepth=8)
+            return FreeimageFormat.Writer._append_data(self, im, meta)
+
+
+class FreeimagePngFormat(FreeimageFormat):
+    """A PNG format based on the Freeimage library.
+
+    This format supports grayscale, RGB and RGBA images.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    not available on the system, it can be downloaded manually from
+    <https://github.com/imageio/imageio-binaries> by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for reading
+    ----------------------
+    ignoregamma : bool
+        Avoid gamma correction. Default True.
+
+    Parameters for saving
+    ---------------------
+    compression : {0, 1, 6, 9}
+        The compression factor. Higher factors result in more
+        compression at the cost of speed. Note that PNG compression is
+        always lossless. Default 9.
+    quantize : int
+        If specified, turn the given RGB or RGBA image in a paletted image
+        for more efficient storage. The value should be between 2 and 256.
+        If the value of 0 the image is not quantized.
+    interlaced : bool
+        Save using Adam7 interlacing. Default False.
+    """
+
+    class Reader(FreeimageFormat.Reader):
+        def _open(self, flags=0, ignoregamma=True):
+            # Build flags from kwargs
+            flags = int(flags)
+            if ignoregamma:
+                flags |= IO_FLAGS.PNG_IGNOREGAMMA
+            # Enter as usual, with modified flags
+            return FreeimageFormat.Reader._open(self, flags)
+
+    # --
+
+    class Writer(FreeimageFormat.Writer):
+        def _open(self, flags=0, compression=9, quantize=0, interlaced=False):
+            compression_map = {
+                0: IO_FLAGS.PNG_Z_NO_COMPRESSION,
+                1: IO_FLAGS.PNG_Z_BEST_SPEED,
+                6: IO_FLAGS.PNG_Z_DEFAULT_COMPRESSION,
+                9: IO_FLAGS.PNG_Z_BEST_COMPRESSION,
+            }
+            # Build flags from kwargs
+            flags = int(flags)
+            if interlaced:
+                flags |= IO_FLAGS.PNG_INTERLACED
+            try:
+                flags |= compression_map[compression]
+            except KeyError:
+                raise ValueError("Png compression must be 0, 1, 6, or 9.")
+            # Act as usual, but with modified flags
+            return FreeimageFormat.Writer._open(self, flags)
+
+        def _append_data(self, im, meta):
+            if str(im.dtype) == "uint16":
+                im = image_as_uint(im, bitdepth=16)
+            else:
+                im = image_as_uint(im, bitdepth=8)
+            FreeimageFormat.Writer._append_data(self, im, meta)
+            # Quantize?
+            q = int(self.request.kwargs.get("quantize", False))
+            if not q:
+                pass
+            elif not (im.ndim == 3 and im.shape[-1] == 3):
+                raise ValueError("Can only quantize RGB images")
+            elif q < 2 or q > 256:
+                raise ValueError("PNG quantize param must be 2..256")
+            else:
+                bm = self._bm.quantize(0, q)
+                self._bm.close()
+                self._bm = bm
+
+
+class FreeimageJpegFormat(FreeimageFormat):
+    """A JPEG format based on the Freeimage library.
+
+    This format supports grayscale and RGB images.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    not available on the system, it can be downloaded manually from
+    <https://github.com/imageio/imageio-binaries> by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for reading
+    ----------------------
+    exifrotate : bool
+        Automatically rotate the image according to the exif flag.
+        Default True. If 2 is given, do the rotation in Python instead
+        of freeimage.
+    quickread : bool
+        Read the image more quickly, at the expense of quality.
+        Default False.
+
+    Parameters for saving
+    ---------------------
+    quality : scalar
+        The compression factor of the saved image (1..100), higher
+        numbers result in higher quality but larger file size. Default 75.
+    progressive : bool
+        Save as a progressive JPEG file (e.g. for images on the web).
+        Default False.
+    optimize : bool
+        On saving, compute optimal Huffman coding tables (can reduce a
+        few percent of file size). Default False.
+    baseline : bool
+        Save basic JPEG, without metadata or any markers. Default False.
+
+    """
+
+    class Reader(FreeimageFormat.Reader):
+        def _open(self, flags=0, exifrotate=True, quickread=False):
+            # Build flags from kwargs
+            flags = int(flags)
+            if exifrotate and exifrotate != 2:
+                flags |= IO_FLAGS.JPEG_EXIFROTATE
+            if not quickread:
+                flags |= IO_FLAGS.JPEG_ACCURATE
+            # Enter as usual, with modified flags
+            return FreeimageFormat.Reader._open(self, flags)
+
+        def _get_data(self, index):
+            im, meta = FreeimageFormat.Reader._get_data(self, index)
+            im = self._rotate(im, meta)
+            return im, meta
+
+        def _rotate(self, im, meta):
+            """Use Orientation information from EXIF meta data to
+            orient the image correctly. Freeimage is also supposed to
+            support that, and I am pretty sure it once did, but now it
+            does not, so let's just do it in Python.
+            Edit: and now it works again, just leave in place as a fallback.
+            """
+            if self.request.kwargs.get("exifrotate", None) == 2:
+                try:
+                    ori = meta["EXIF_MAIN"]["Orientation"]
+                except KeyError:  # pragma: no cover
+                    pass  # Orientation not available
+                else:  # pragma: no cover - we cannot touch all cases
+                    # www.impulseadventure.com/photo/exif-orientation.html
+                    if ori in [1, 2]:
+                        pass
+                    if ori in [3, 4]:
+                        im = np.rot90(im, 2)
+                    if ori in [5, 6]:
+                        im = np.rot90(im, 3)
+                    if ori in [7, 8]:
+                        im = np.rot90(im)
+                    if ori in [2, 4, 5, 7]:  # Flipped cases (rare)
+                        im = np.fliplr(im)
+            return im
+
+    # --
+
+    class Writer(FreeimageFormat.Writer):
+        def _open(
+            self, flags=0, quality=75, progressive=False, optimize=False, baseline=False
+        ):
+            # Test quality
+            quality = int(quality)
+            if quality < 1 or quality > 100:
+                raise ValueError("JPEG quality should be between 1 and 100.")
+            # Build flags from kwargs
+            flags = int(flags)
+            flags |= quality
+            if progressive:
+                flags |= IO_FLAGS.JPEG_PROGRESSIVE
+            if optimize:
+                flags |= IO_FLAGS.JPEG_OPTIMIZE
+            if baseline:
+                flags |= IO_FLAGS.JPEG_BASELINE
+            # Act as usual, but with modified flags
+            return FreeimageFormat.Writer._open(self, flags)
+
+        def _append_data(self, im, meta):
+            if im.ndim == 3 and im.shape[-1] == 4:
+                raise IOError("JPEG does not support alpha channel.")
+            im = image_as_uint(im, bitdepth=8)
+            return FreeimageFormat.Writer._append_data(self, im, meta)
+
+
+class FreeimagePnmFormat(FreeimageFormat):
+    """A PNM format based on the Freeimage library.
+
+    This format supports single bit (PBM), grayscale (PGM) and RGB (PPM)
+    images, even with ASCII or binary coding.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    not available on the system, it can be downloaded manually from
+    <https://github.com/imageio/imageio-binaries> by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for saving
+    ---------------------
+    use_ascii : bool
+        Save with ASCII coding. Default True.
+    """
+
+    class Writer(FreeimageFormat.Writer):
+        def _open(self, flags=0, use_ascii=True):
+            # Build flags from kwargs
+            flags = int(flags)
+            if use_ascii:
+                flags |= IO_FLAGS.PNM_SAVE_ASCII
+            # Act as usual, but with modified flags
+            return FreeimageFormat.Writer._open(self, flags)

minigpt2/lib/python3.10/site-packages/imageio/plugins/freeimagemulti.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Plugin for multi-image freeimafe formats, like animated GIF and ico.
+"""
+
+import logging
+import numpy as np
+
+from ..core import Format, image_as_uint
+from ._freeimage import fi, IO_FLAGS
+from .freeimage import FreeimageFormat
+
+logger = logging.getLogger(__name__)
+
+
+class FreeimageMulti(FreeimageFormat):
+    """Base class for freeimage formats that support multiple images."""
+
+    _modes = "iI"
+    _fif = -1
+
+    class Reader(Format.Reader):
+        def _open(self, flags=0):
+            flags = int(flags)
+            # Create bitmap
+            self._bm = fi.create_multipage_bitmap(
+                self.request.filename, self.format.fif, flags
+            )
+            self._bm.load_from_filename(self.request.get_local_filename())
+
+        def _close(self):
+            self._bm.close()
+
+        def _get_length(self):
+            return len(self._bm)
+
+        def _get_data(self, index):
+            sub = self._bm.get_page(index)
+            try:
+                return sub.get_image_data(), sub.get_meta_data()
+            finally:
+                sub.close()
+
+        def _get_meta_data(self, index):
+            index = index or 0
+            if index < 0 or index >= len(self._bm):
+                raise IndexError()
+            sub = self._bm.get_page(index)
+            try:
+                return sub.get_meta_data()
+            finally:
+                sub.close()
+
+    # --
+
+    class Writer(FreeimageFormat.Writer):
+        def _open(self, flags=0):
+            # Set flags
+            self._flags = flags = int(flags)
+            # Instantiate multi-page bitmap
+            self._bm = fi.create_multipage_bitmap(
+                self.request.filename, self.format.fif, flags
+            )
+            self._bm.save_to_filename(self.request.get_local_filename())
+
+        def _close(self):
+            # Close bitmap
+            self._bm.close()
+
+        def _append_data(self, im, meta):
+            # Prepare data
+            if im.ndim == 3 and im.shape[-1] == 1:
+                im = im[:, :, 0]
+            im = image_as_uint(im, bitdepth=8)
+            # Create sub bitmap
+            sub1 = fi.create_bitmap(self._bm._filename, self.format.fif)
+            # Let subclass add data to bitmap, optionally return new
+            sub2 = self._append_bitmap(im, meta, sub1)
+            # Add
+            self._bm.append_bitmap(sub2)
+            sub2.close()
+            if sub1 is not sub2:
+                sub1.close()
+
+        def _append_bitmap(self, im, meta, bitmap):
+            # Set data
+            bitmap.allocate(im)
+            bitmap.set_image_data(im)
+            bitmap.set_meta_data(meta)
+            # Return that same bitmap
+            return bitmap
+
+        def _set_meta_data(self, meta):
+            pass  # ignore global meta data
+
+
+class MngFormat(FreeimageMulti):
+    """An Mng format based on the Freeimage library.
+
+    Read only. Seems broken.
+    """
+
+    _fif = 6
+
+    def _can_write(self, request):  # pragma: no cover
+        return False
+
+
+class IcoFormat(FreeimageMulti):
+    """An ICO format based on the Freeimage library.
+
+    This format supports grayscale, RGB and RGBA images.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    is not available on the system, it can be downloaded by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for reading
+    ----------------------
+    makealpha : bool
+        Convert to 32-bit and create an alpha channel from the AND-
+        mask when loading. Default False. Note that this returns wrong
+        results if the image was already RGBA.
+
+    """
+
+    _fif = 1
+
+    class Reader(FreeimageMulti.Reader):
+        def _open(self, flags=0, makealpha=False):
+            # Build flags from kwargs
+            flags = int(flags)
+            if makealpha:
+                flags |= IO_FLAGS.ICO_MAKEALPHA
+            return FreeimageMulti.Reader._open(self, flags)
+
+
+class GifFormat(FreeimageMulti):
+    """A format for reading and writing static and animated GIF, based
+    on the Freeimage library.
+
+    Images read with this format are always RGBA. Currently,
+    the alpha channel is ignored when saving RGB images with this
+    format.
+
+    The freeimage plugin requires a `freeimage` binary. If this binary
+    is not available on the system, it can be downloaded by either
+
+    - the command line script ``imageio_download_bin freeimage``
+    - the Python method ``imageio.plugins.freeimage.download()``
+
+    Parameters for reading
+    ----------------------
+    playback : bool
+        'Play' the GIF to generate each frame (as 32bpp) instead of
+        returning raw frame data when loading. Default True.
+
+    Parameters for saving
+    ---------------------
+    loop : int
+        The number of iterations. Default 0 (meaning loop indefinitely)
+    duration : {float, list}
+        The duration (in seconds) of each frame. Either specify one value
+        that is used for all frames, or one value for each frame.
+        Note that in the GIF format the duration/delay is expressed in
+        hundredths of a second, which limits the precision of the duration.
+    fps : float
+        The number of frames per second. If duration is not given, the
+        duration for each frame is set to 1/fps. Default 10.
+    palettesize : int
+        The number of colors to quantize the image to. Is rounded to
+        the nearest power of two. Default 256.
+    quantizer : {'wu', 'nq'}
+        The quantization algorithm:
+            * wu - Wu, Xiaolin, Efficient Statistical Computations for
+              Optimal Color Quantization
+            * nq (neuqant) - Dekker A. H., Kohonen neural networks for
+              optimal color quantization
+    subrectangles : bool
+        If True, will try and optimize the GIF by storing only the
+        rectangular parts of each frame that change with respect to the
+        previous. Unfortunately, this option seems currently broken
+        because FreeImage does not handle DisposalMethod correctly.
+        Default False.
+    """
+
+    _fif = 25
+
+    class Reader(FreeimageMulti.Reader):
+        def _open(self, flags=0, playback=True):
+            # Build flags from kwargs
+            flags = int(flags)
+            if playback:
+                flags |= IO_FLAGS.GIF_PLAYBACK
+            FreeimageMulti.Reader._open(self, flags)
+
+        def _get_data(self, index):
+            im, meta = FreeimageMulti.Reader._get_data(self, index)
+            # im = im[:, :, :3]  # Drop alpha channel
+            return im, meta
+
+    # -- writer
+
+    class Writer(FreeimageMulti.Writer):
+        # todo: subrectangles
+        # todo: global palette
+
+        def _open(
+            self,
+            flags=0,
+            loop=0,
+            duration=None,
+            fps=10,
+            palettesize=256,
+            quantizer="Wu",
+            subrectangles=False,
+        ):
+            # Check palettesize
+            if palettesize < 2 or palettesize > 256:
+                raise ValueError("GIF quantize param must be 2..256")
+            if palettesize not in [2, 4, 8, 16, 32, 64, 128, 256]:
+                palettesize = 2 ** int(np.log2(128) + 0.999)
+                logger.warning(
+                    "Warning: palettesize (%r) modified to a factor of "
+                    "two between 2-256." % palettesize
+                )
+            self._palettesize = palettesize
+            # Check quantizer
+            self._quantizer = {"wu": 0, "nq": 1}.get(quantizer.lower(), None)
+            if self._quantizer is None:
+                raise ValueError('Invalid quantizer, must be "wu" or "nq".')
+            # Check frametime
+            if duration is None:
+                self._frametime = [int(1000 / float(fps) + 0.5)]
+            elif isinstance(duration, list):
+                self._frametime = [int(1000 * d) for d in duration]
+            elif isinstance(duration, (float, int)):
+                self._frametime = [int(1000 * duration)]
+            else:
+                raise ValueError("Invalid value for duration: %r" % duration)
+            # Check subrectangles
+            self._subrectangles = bool(subrectangles)
+            self._prev_im = None
+            # Init
+            FreeimageMulti.Writer._open(self, flags)
+            # Set global meta data
+            self._meta = {}
+            self._meta["ANIMATION"] = {
+                # 'GlobalPalette': np.array([0]).astype(np.uint8),
+                "Loop": np.array([loop]).astype(np.uint32),
+                # 'LogicalWidth': np.array([x]).astype(np.uint16),
+                # 'LogicalHeight': np.array([x]).astype(np.uint16),
+            }
+
+        def _append_bitmap(self, im, meta, bitmap):
+            # Prepare meta data
+            meta = meta.copy()
+            meta_a = meta["ANIMATION"] = {}
+            # If this is the first frame, assign it our "global" meta data
+            if len(self._bm) == 0:
+                meta.update(self._meta)
+                meta_a = meta["ANIMATION"]
+            # Set frame time
+            index = len(self._bm)
+            if index < len(self._frametime):
+                ft = self._frametime[index]
+            else:
+                ft = self._frametime[-1]
+            meta_a["FrameTime"] = np.array([ft]).astype(np.uint32)
+            # Check array
+            if im.ndim == 3 and im.shape[-1] == 4:
+                im = im[:, :, :3]
+            # Process subrectangles
+            im_uncropped = im
+            if self._subrectangles and self._prev_im is not None:
+                im, xy = self._get_sub_rectangles(self._prev_im, im)
+                meta_a["DisposalMethod"] = np.array([1]).astype(np.uint8)
+                meta_a["FrameLeft"] = np.array([xy[0]]).astype(np.uint16)
+                meta_a["FrameTop"] = np.array([xy[1]]).astype(np.uint16)
+            self._prev_im = im_uncropped
+            # Set image data
+            sub2 = sub1 = bitmap
+            sub1.allocate(im)
+            sub1.set_image_data(im)
+            # Quantize it if its RGB
+            if im.ndim == 3 and im.shape[-1] == 3:
+                sub2 = sub1.quantize(self._quantizer, self._palettesize)
+            # Set meta data and return
+            sub2.set_meta_data(meta)
+            return sub2
+
+        def _get_sub_rectangles(self, prev, im):
+            """
+            Calculate the minimal rectangles that need updating each frame.
+            Returns a two-element tuple containing the cropped images and a
+            list of x-y positions.
+            """
+            # Get difference, sum over colors
+            diff = np.abs(im - prev)
+            if diff.ndim == 3:
+                diff = diff.sum(2)
+            # Get begin and end for both dimensions
+            X = np.argwhere(diff.sum(0))
+            Y = np.argwhere(diff.sum(1))
+            # Get rect coordinates
+            if X.size and Y.size:
+                x0, x1 = int(X[0]), int(X[-1]) + 1
+                y0, y1 = int(Y[0]), int(Y[-1]) + 1
+            else:  # No change ... make it minimal
+                x0, x1 = 0, 2
+                y0, y1 = 0, 2
+            # Cut out and return
+            return im[y0:y1, x0:x1], (x0, y0)

minigpt2/lib/python3.10/site-packages/imageio/plugins/gdal.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read GDAL files.
+
+Backend: `GDAL <https://gdal.org/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[gdal]
+
+Parameters
+----------
+none
+"""
+
+from ..core import Format, has_module
+
+_gdal = None  # lazily loaded in load_lib()
+
+
+def load_lib():
+    global _gdal
+    try:
+        import osgeo.gdal as _gdal
+    except ImportError:
+        raise ImportError(
+            "The GDAL format relies on the GDAL package."
+            "Please refer to http://www.gdal.org/"
+            "for further instructions."
+        )
+    return _gdal
+
+
+GDAL_FORMATS = (".tiff", " .tif", ".img", ".ecw", ".jpg", ".jpeg")
+
+
+class GdalFormat(Format):
+    """See :mod:`imageio.plugins.gdal`"""
+
+    def _can_read(self, request):
+        if request.extension in (".ecw",):
+            return True
+        if has_module("osgeo.gdal"):
+            return request.extension in self.extensions
+
+    def _can_write(self, request):
+        return False
+
+    # --
+
+    class Reader(Format.Reader):
+        def _open(self):
+            if not _gdal:
+                load_lib()
+            self._ds = _gdal.Open(self.request.get_local_filename())
+
+        def _close(self):
+            del self._ds
+
+        def _get_length(self):
+            return 1
+
+        def _get_data(self, index):
+            if index != 0:
+                raise IndexError("Gdal file contains only one dataset")
+            return self._ds.ReadAsArray(), self._get_meta_data(index)
+
+        def _get_meta_data(self, index):
+            return self._ds.GetMetadata()

minigpt2/lib/python3.10/site-packages/imageio/plugins/grab.py

@@ -0,0 +1,105 @@
+"""
+PIL-based formats to take screenshots and grab from the clipboard.
+"""
+
+import threading
+
+import numpy as np
+
+from ..core import Format
+
+
+class BaseGrabFormat(Format):
+    """Base format for grab formats."""
+
+    _pillow_imported = False
+    _ImageGrab = None
+
+    def __init__(self, *args, **kwargs):
+        super(BaseGrabFormat, self).__init__(*args, **kwargs)
+        self._lock = threading.RLock()
+
+    def _can_write(self, request):
+        return False
+
+    def _init_pillow(self):
+        with self._lock:
+            if not self._pillow_imported:
+                self._pillow_imported = True  # more like tried to import
+                import PIL
+
+                if not hasattr(PIL, "__version__"):  # pragma: no cover
+                    raise ImportError("Imageio Pillow requires " "Pillow, not PIL!")
+                try:
+                    from PIL import ImageGrab
+                except ImportError:
+                    return None
+                self._ImageGrab = ImageGrab
+        return self._ImageGrab
+
+    class Reader(Format.Reader):
+        def _open(self):
+            pass
+
+        def _close(self):
+            pass
+
+        def _get_data(self, index):
+            return self.format._get_data(index)
+
+
+class ScreenGrabFormat(BaseGrabFormat):
+    """The ScreenGrabFormat provided a means to grab screenshots using
+    the uri of "<screen>".
+
+    This functionality is provided via Pillow. Note that "<screen>" is
+    only supported on Windows and OS X.
+
+    Parameters for reading
+    ----------------------
+    No parameters.
+    """
+
+    def _can_read(self, request):
+        if request.filename != "<screen>":
+            return False
+        return bool(self._init_pillow())
+
+    def _get_data(self, index):
+        ImageGrab = self._init_pillow()
+        assert ImageGrab
+
+        pil_im = ImageGrab.grab()
+        assert pil_im is not None
+        im = np.asarray(pil_im)
+        return im, {}
+
+
+class ClipboardGrabFormat(BaseGrabFormat):
+    """The ClipboardGrabFormat provided a means to grab image data from
+    the clipboard, using the uri "<clipboard>"
+
+    This functionality is provided via Pillow. Note that "<clipboard>" is
+    only supported on Windows.
+
+    Parameters for reading
+    ----------------------
+    No parameters.
+    """
+
+    def _can_read(self, request):
+        if request.filename != "<clipboard>":
+            return False
+        return bool(self._init_pillow())
+
+    def _get_data(self, index):
+        ImageGrab = self._init_pillow()
+        assert ImageGrab
+
+        pil_im = ImageGrab.grabclipboard()
+        if pil_im is None:
+            raise RuntimeError(
+                "There seems to be no image data on the " "clipboard now."
+            )
+        im = np.asarray(pil_im)
+        return im, {}