Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/gradio_client/__init__.py

@@ -0,0 +1,7 @@
+from gradio_client.client import Client
+from gradio_client.utils import __version__
+
+__all__ = [
+    "Client",
+    "__version__",
+]

parrot/lib/python3.10/site-packages/gradio_client/client.py

@@ -0,0 +1,1114 @@
+"""The main Client class for the Python client."""
+from __future__ import annotations
+
+import concurrent.futures
+import json
+import os
+import re
+import tempfile
+import threading
+import time
+import urllib.parse
+import uuid
+import warnings
+from concurrent.futures import Future, TimeoutError
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Literal
+
+import huggingface_hub
+import requests
+import websockets
+from huggingface_hub import SpaceHardware, SpaceStage
+from huggingface_hub.utils import (
+    RepositoryNotFoundError,
+    build_hf_headers,
+    send_telemetry,
+)
+from packaging import version
+
+from gradio_client import serializing, utils
+from gradio_client.documentation import document, set_documentation_group
+from gradio_client.serializing import Serializable
+from gradio_client.utils import (
+    Communicator,
+    JobStatus,
+    Status,
+    StatusUpdate,
+)
+
+set_documentation_group("py-client")
+
+
+DEFAULT_TEMP_DIR = os.environ.get("GRADIO_TEMP_DIR") or str(
+    Path(tempfile.gettempdir()) / "gradio"
+)
+
+
+@document("predict", "submit", "view_api", "duplicate")
+class Client:
+    """
+    The main Client class for the Python client. This class is used to connect to a remote Gradio app and call its API endpoints.
+
+    Example:
+        from gradio_client import Client
+
+        client = Client("abidlabs/whisper-large-v2")  # connecting to a Hugging Face Space
+        client.predict("test.mp4", api_name="/predict")
+        >> What a nice recording! # returns the result of the remote API call
+
+        client = Client("https://bec81a83-5b5c-471e.gradio.live")  # connecting to a temporary Gradio share URL
+        job = client.submit("hello", api_name="/predict")  # runs the prediction in a background thread
+        job.result()
+        >> 49 # returns the result of the remote API call (blocking call)
+    """
+
+    def __init__(
+        self,
+        src: str,
+        hf_token: str | None = None,
+        max_workers: int = 40,
+        serialize: bool = True,
+        output_dir: str | Path | None = DEFAULT_TEMP_DIR,
+        verbose: bool = True,
+    ):
+        """
+        Parameters:
+            src: Either the name of the Hugging Face Space to load, (e.g. "abidlabs/whisper-large-v2") or the full URL (including "http" or "https") of the hosted Gradio app to load (e.g. "http://mydomain.com/app" or "https://bec81a83-5b5c-471e.gradio.live/").
+            hf_token: The Hugging Face token to use to access private Spaces. Automatically fetched if you are logged in via the Hugging Face Hub CLI. Obtain from: https://huggingface.co/settings/token
+            max_workers: The maximum number of thread workers that can be used to make requests to the remote Gradio app simultaneously.
+            serialize: Whether the client should serialize the inputs and deserialize the outputs of the remote API. If set to False, the client will pass the inputs and outputs as-is, without serializing/deserializing them. E.g. you if you set this to False, you'd submit an image in base64 format instead of a filepath, and you'd get back an image in base64 format from the remote API instead of a filepath.
+            output_dir: The directory to save files that are downloaded from the remote API. If None, reads from the GRADIO_TEMP_DIR environment variable. Defaults to a temporary directory on your machine.
+            verbose: Whether the client should print statements to the console.
+        """
+        self.verbose = verbose
+        self.hf_token = hf_token
+        self.serialize = serialize
+        self.headers = build_hf_headers(
+            token=hf_token,
+            library_name="gradio_client",
+            library_version=utils.__version__,
+        )
+        self.space_id = None
+        self.output_dir = output_dir
+
+        if src.startswith("http://") or src.startswith("https://"):
+            _src = src if src.endswith("/") else src + "/"
+        else:
+            _src = self._space_name_to_src(src)
+            if _src is None:
+                raise ValueError(
+                    f"Could not find Space: {src}. If it is a private Space, please provide an hf_token."
+                )
+            self.space_id = src
+        self.src = _src
+        state = self._get_space_state()
+        if state == SpaceStage.BUILDING:
+            if self.verbose:
+                print("Space is still building. Please wait...")
+            while self._get_space_state() == SpaceStage.BUILDING:
+                time.sleep(2)  # so we don't get rate limited by the API
+                pass
+        if state in utils.INVALID_RUNTIME:
+            raise ValueError(
+                f"The current space is in the invalid state: {state}. "
+                "Please contact the owner to fix this."
+            )
+        if self.verbose:
+            print(f"Loaded as API: {self.src} ✔")
+
+        self.api_url = urllib.parse.urljoin(self.src, utils.API_URL)
+        self.ws_url = urllib.parse.urljoin(
+            self.src.replace("http", "ws", 1), utils.WS_URL
+        )
+        self.upload_url = urllib.parse.urljoin(self.src, utils.UPLOAD_URL)
+        self.reset_url = urllib.parse.urljoin(self.src, utils.RESET_URL)
+        self.config = self._get_config()
+        self.session_hash = str(uuid.uuid4())
+
+        self.endpoints = [
+            Endpoint(self, fn_index, dependency)
+            for fn_index, dependency in enumerate(self.config["dependencies"])
+        ]
+
+        # Create a pool of threads to handle the requests
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
+
+        # Disable telemetry by setting the env variable HF_HUB_DISABLE_TELEMETRY=1
+        threading.Thread(target=self._telemetry_thread).start()
+
+    @classmethod
+    def duplicate(
+        cls,
+        from_id: str,
+        to_id: str | None = None,
+        hf_token: str | None = None,
+        private: bool = True,
+        hardware: Literal[
+            "cpu-basic",
+            "cpu-upgrade",
+            "t4-small",
+            "t4-medium",
+            "a10g-small",
+            "a10g-large",
+            "a100-large",
+        ]
+        | SpaceHardware
+        | None = None,
+        secrets: dict[str, str] | None = None,
+        sleep_timeout: int = 5,
+        max_workers: int = 40,
+        verbose: bool = True,
+    ):
+        """
+        Duplicates a Hugging Face Space under your account and returns a Client object
+        for the new Space. No duplication is created if the Space already exists in your
+        account (to override this, provide a new name for the new Space using `to_id`).
+        To use this method, you must provide an `hf_token` or be logged in via the Hugging
+        Face Hub CLI.
+
+        The new Space will be private by default and use the same hardware as the original
+        Space. This can be changed by using the `private` and `hardware` parameters. For
+        hardware upgrades (beyond the basic CPU tier), you may be required to provide
+        billing information on Hugging Face: https://huggingface.co/settings/billing
+
+        Parameters:
+            from_id: The name of the Hugging Face Space to duplicate in the format "{username}/{space_id}", e.g. "gradio/whisper".
+            to_id: The name of the new Hugging Face Space to create, e.g. "abidlabs/whisper-duplicate". If not provided, the new Space will be named "{your_HF_username}/{space_id}".
+            hf_token: The Hugging Face token to use to access private Spaces. Automatically fetched if you are logged in via the Hugging Face Hub CLI. Obtain from: https://huggingface.co/settings/token
+            private: Whether the new Space should be private (True) or public (False). Defaults to True.
+            hardware: The hardware tier to use for the new Space. Defaults to the same hardware tier as the original Space. Options include "cpu-basic", "cpu-upgrade", "t4-small", "t4-medium", "a10g-small", "a10g-large", "a100-large", subject to availability.
+            secrets: A dictionary of (secret key, secret value) to pass to the new Space. Defaults to None. Secrets are only used when the Space is duplicated for the first time, and are not updated if the duplicated Space already exists.
+            sleep_timeout: The number of minutes after which the duplicate Space will be puased if no requests are made to it (to minimize billing charges). Defaults to 5 minutes.
+            max_workers: The maximum number of thread workers that can be used to make requests to the remote Gradio app simultaneously.
+            verbose: Whether the client should print statements to the console.
+        Example:
+            import os
+            from gradio_client import Client
+            HF_TOKEN = os.environ.get("HF_TOKEN")
+            client = Client.duplicate("abidlabs/whisper", hf_token=HF_TOKEN)
+            client.predict("audio_sample.wav")
+            >> "This is a test of the whisper speech recognition model."
+        """
+        try:
+            original_info = huggingface_hub.get_space_runtime(from_id, token=hf_token)
+        except RepositoryNotFoundError as rnfe:
+            raise ValueError(
+                f"Could not find Space: {from_id}. If it is a private Space, please provide an `hf_token`."
+            ) from rnfe
+        if to_id:
+            if "/" in to_id:
+                to_id = to_id.split("/")[1]
+            space_id = huggingface_hub.get_full_repo_name(to_id, token=hf_token)
+        else:
+            space_id = huggingface_hub.get_full_repo_name(
+                from_id.split("/")[1], token=hf_token
+            )
+        try:
+            huggingface_hub.get_space_runtime(space_id, token=hf_token)
+            if verbose:
+                print(
+                    f"Using your existing Space: {utils.SPACE_URL.format(space_id)} 🤗"
+                )
+            if secrets is not None:
+                warnings.warn(
+                    "Secrets are only used when the Space is duplicated for the first time, and are not updated if the duplicated Space already exists."
+                )
+        except RepositoryNotFoundError:
+            if verbose:
+                print(f"Creating a duplicate of {from_id} for your own use... 🤗")
+            huggingface_hub.duplicate_space(
+                from_id=from_id,
+                to_id=space_id,
+                token=hf_token,
+                exist_ok=True,
+                private=private,
+            )
+            if secrets is not None:
+                for key, value in secrets.items():
+                    huggingface_hub.add_space_secret(
+                        space_id, key, value, token=hf_token
+                    )
+            if verbose:
+                print(f"Created new Space: {utils.SPACE_URL.format(space_id)}")
+        current_info = huggingface_hub.get_space_runtime(space_id, token=hf_token)
+        current_hardware = (
+            current_info.hardware or huggingface_hub.SpaceHardware.CPU_BASIC
+        )
+        hardware = hardware or original_info.hardware
+        if current_hardware != hardware:
+            huggingface_hub.request_space_hardware(space_id, hardware)  # type: ignore
+            print(
+                f"-------\nNOTE: this Space uses upgraded hardware: {hardware}... see billing info at https://huggingface.co/settings/billing\n-------"
+            )
+        # Setting a timeout only works if the hardware is not basic
+        # so set it here after the hardware has been requested
+        if hardware != huggingface_hub.SpaceHardware.CPU_BASIC:
+            utils.set_space_timeout(
+                space_id, hf_token=hf_token, timeout_in_seconds=sleep_timeout * 60
+            )
+        if verbose:
+            print("")
+        client = cls(
+            space_id, hf_token=hf_token, max_workers=max_workers, verbose=verbose
+        )
+        return client
+
+    def _get_space_state(self):
+        if not self.space_id:
+            return None
+        info = huggingface_hub.get_space_runtime(self.space_id, token=self.hf_token)
+        return info.stage
+
+    def predict(
+        self,
+        *args,
+        api_name: str | None = None,
+        fn_index: int | None = None,
+    ) -> Any:
+        """
+        Calls the Gradio API and returns the result (this is a blocking call).
+
+        Parameters:
+            args: The arguments to pass to the remote API. The order of the arguments must match the order of the inputs in the Gradio app.
+            api_name: The name of the API endpoint to call starting with a leading slash, e.g. "/predict". Does not need to be provided if the Gradio app has only one named API endpoint.
+            fn_index: As an alternative to api_name, this parameter takes the index of the API endpoint to call, e.g. 0. Both api_name and fn_index can be provided, but if they conflict, api_name will take precedence.
+        Returns:
+            The result of the API call. Will be a Tuple if the API has multiple outputs.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            client.predict(5, "add", 4, api_name="/predict")
+            >> 9.0
+        """
+        return self.submit(*args, api_name=api_name, fn_index=fn_index).result()
+
+    def submit(
+        self,
+        *args,
+        api_name: str | None = None,
+        fn_index: int | None = None,
+        result_callbacks: Callable | list[Callable] | None = None,
+    ) -> Job:
+        """
+        Creates and returns a Job object which calls the Gradio API in a background thread. The job can be used to retrieve the status and result of the remote API call.
+
+        Parameters:
+            args: The arguments to pass to the remote API. The order of the arguments must match the order of the inputs in the Gradio app.
+            api_name: The name of the API endpoint to call starting with a leading slash, e.g. "/predict". Does not need to be provided if the Gradio app has only one named API endpoint.
+            fn_index: As an alternative to api_name, this parameter takes the index of the API endpoint to call, e.g. 0. Both api_name and fn_index can be provided, but if they conflict, api_name will take precedence.
+            result_callbacks: A callback function, or list of callback functions, to be called when the result is ready. If a list of functions is provided, they will be called in order. The return values from the remote API are provided as separate parameters into the callback. If None, no callback will be called.
+        Returns:
+            A Job object that can be used to retrieve the status and result of the remote API call.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            job = client.submit(5, "add", 4, api_name="/predict")
+            job.status()
+            >> <Status.STARTING: 'STARTING'>
+            job.result()  # blocking call
+            >> 9.0
+        """
+        inferred_fn_index = self._infer_fn_index(api_name, fn_index)
+
+        helper = None
+        if self.endpoints[inferred_fn_index].use_ws:
+            helper = Communicator(
+                Lock(),
+                JobStatus(),
+                self.endpoints[inferred_fn_index].process_predictions,
+                self.reset_url,
+            )
+        end_to_end_fn = self.endpoints[inferred_fn_index].make_end_to_end_fn(helper)
+        future = self.executor.submit(end_to_end_fn, *args)
+
+        job = Job(
+            future, communicator=helper, verbose=self.verbose, space_id=self.space_id
+        )
+
+        if result_callbacks:
+            if isinstance(result_callbacks, Callable):
+                result_callbacks = [result_callbacks]
+
+            def create_fn(callback) -> Callable:
+                def fn(future):
+                    if isinstance(future.result(), tuple):
+                        callback(*future.result())
+                    else:
+                        callback(future.result())
+
+                return fn
+
+            for callback in result_callbacks:
+                job.add_done_callback(create_fn(callback))
+
+        return job
+
+    def view_api(
+        self,
+        all_endpoints: bool | None = None,
+        print_info: bool = True,
+        return_format: Literal["dict", "str"] | None = None,
+    ) -> dict | str | None:
+        """
+        Prints the usage info for the API. If the Gradio app has multiple API endpoints, the usage info for each endpoint will be printed separately. If return_format="dict" the info is returned in dictionary format, as shown in the example below.
+
+        Parameters:
+            all_endpoints: If True, prints information for both named and unnamed endpoints in the Gradio app. If False, will only print info about named endpoints. If None (default), will print info about named endpoints, unless there aren't any -- in which it will print info about unnamed endpoints.
+            print_info: If True, prints the usage info to the console. If False, does not print the usage info.
+            return_format: If None, nothing is returned. If "str", returns the same string that would be printed to the console. If "dict", returns the usage info as a dictionary that can be programmatically parsed, and *all endpoints are returned in the dictionary* regardless of the value of `all_endpoints`. The format of the dictionary is in the docstring of this method.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            client.view_api(return_format="dict")
+            >> {
+                'named_endpoints': {
+                    '/predict': {
+                        'parameters': [
+                            {
+                                'label': 'num1',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                                'example_input': '5'
+                            },
+                            {
+                                'label': 'operation',
+                                'type_python': 'str',
+                                'type_description': 'string value',
+                                'component': 'Radio',
+                                'example_input': 'add'
+                            },
+                            {
+                                'label': 'num2',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                                'example_input': '5'
+                            },
+                        ],
+                        'returns': [
+                            {
+                                'label': 'output',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                            },
+                        ]
+                    },
+                    '/flag': {
+                        'parameters': [
+                            ...
+                            ],
+                        'returns': [
+                            ...
+                            ]
+                        }
+                    }
+                'unnamed_endpoints': {
+                    2: {
+                        'parameters': [
+                            ...
+                            ],
+                        'returns': [
+                            ...
+                            ]
+                        }
+                    }
+                }
+            }
+
+        """
+        if self.serialize:
+            api_info_url = urllib.parse.urljoin(self.src, utils.API_INFO_URL)
+        else:
+            api_info_url = urllib.parse.urljoin(self.src, utils.RAW_API_INFO_URL)
+
+        # Versions of Gradio older than 3.29.0 returned format of the API info
+        # from the /info endpoint
+        if version.parse(self.config.get("version", "2.0")) > version.Version("3.29.0"):
+            r = requests.get(api_info_url, headers=self.headers)
+            if r.ok:
+                info = r.json()
+            else:
+                raise ValueError(f"Could not fetch api info for {self.src}")
+        else:
+            fetch = requests.post(
+                utils.SPACE_FETCHER_URL,
+                json={"config": json.dumps(self.config), "serialize": self.serialize},
+            )
+            if fetch.ok:
+                info = fetch.json()["api"]
+            else:
+                raise ValueError(f"Could not fetch api info for {self.src}")
+        num_named_endpoints = len(info["named_endpoints"])
+        num_unnamed_endpoints = len(info["unnamed_endpoints"])
+        if num_named_endpoints == 0 and all_endpoints is None:
+            all_endpoints = True
+
+        human_info = "Client.predict() Usage Info\n---------------------------\n"
+        human_info += f"Named API endpoints: {num_named_endpoints}\n"
+
+        for api_name, endpoint_info in info["named_endpoints"].items():
+            human_info += self._render_endpoints_info(api_name, endpoint_info)
+
+        if all_endpoints:
+            human_info += f"\nUnnamed API endpoints: {num_unnamed_endpoints}\n"
+            for fn_index, endpoint_info in info["unnamed_endpoints"].items():
+                # When loading from json, the fn_indices are read as strings
+                # because json keys can only be strings
+                human_info += self._render_endpoints_info(int(fn_index), endpoint_info)
+        else:
+            if num_unnamed_endpoints > 0:
+                human_info += f"\nUnnamed API endpoints: {num_unnamed_endpoints}, to view, run Client.view_api(all_endpoints=True)\n"
+
+        if print_info:
+            print(human_info)
+        if return_format == "str":
+            return human_info
+        elif return_format == "dict":
+            return info
+
+    def reset_session(self) -> None:
+        self.session_hash = str(uuid.uuid4())
+
+    def _render_endpoints_info(
+        self,
+        name_or_index: str | int,
+        endpoints_info: dict[str, list[dict[str, Any]]],
+    ) -> str:
+        parameter_names = [p["label"] for p in endpoints_info["parameters"]]
+        parameter_names = [utils.sanitize_parameter_names(p) for p in parameter_names]
+        rendered_parameters = ", ".join(parameter_names)
+        if rendered_parameters:
+            rendered_parameters = rendered_parameters + ", "
+        return_values = [p["label"] for p in endpoints_info["returns"]]
+        return_values = [utils.sanitize_parameter_names(r) for r in return_values]
+        rendered_return_values = ", ".join(return_values)
+        if len(return_values) > 1:
+            rendered_return_values = f"({rendered_return_values})"
+
+        if isinstance(name_or_index, str):
+            final_param = f'api_name="{name_or_index}"'
+        elif isinstance(name_or_index, int):
+            final_param = f"fn_index={name_or_index}"
+        else:
+            raise ValueError("name_or_index must be a string or integer")
+
+        human_info = f"\n - predict({rendered_parameters}{final_param}) -> {rendered_return_values}\n"
+        human_info += "    Parameters:\n"
+        if endpoints_info["parameters"]:
+            for info in endpoints_info["parameters"]:
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
+        else:
+            human_info += "     - None\n"
+        human_info += "    Returns:\n"
+        if endpoints_info["returns"]:
+            for info in endpoints_info["returns"]:
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
+        else:
+            human_info += "     - None\n"
+
+        return human_info
+
+    def __repr__(self):
+        return self.view_api(print_info=False, return_format="str")
+
+    def __str__(self):
+        return self.view_api(print_info=False, return_format="str")
+
+    def _telemetry_thread(self) -> None:
+        # Disable telemetry by setting the env variable HF_HUB_DISABLE_TELEMETRY=1
+        data = {
+            "src": self.src,
+        }
+        try:
+            send_telemetry(
+                topic="py_client/initiated",
+                library_name="gradio_client",
+                library_version=utils.__version__,
+                user_agent=data,
+            )
+        except Exception:
+            pass
+
+    def _infer_fn_index(self, api_name: str | None, fn_index: int | None) -> int:
+        inferred_fn_index = None
+        if api_name is not None:
+            for i, d in enumerate(self.config["dependencies"]):
+                config_api_name = d.get("api_name")
+                if config_api_name is None or config_api_name is False:
+                    continue
+                if "/" + config_api_name == api_name:
+                    inferred_fn_index = i
+                    break
+            else:
+                error_message = f"Cannot find a function with `api_name`: {api_name}."
+                if not api_name.startswith("/"):
+                    error_message += " Did you mean to use a leading slash?"
+                raise ValueError(error_message)
+        elif fn_index is not None:
+            inferred_fn_index = fn_index
+        else:
+            valid_endpoints = [
+                e for e in self.endpoints if e.is_valid and e.api_name is not None
+            ]
+            if len(valid_endpoints) == 1:
+                inferred_fn_index = valid_endpoints[0].fn_index
+            else:
+                raise ValueError(
+                    "This Gradio app might have multiple endpoints. Please specify an `api_name` or `fn_index`"
+                )
+        return inferred_fn_index
+
+    def __del__(self):
+        if hasattr(self, "executor"):
+            self.executor.shutdown(wait=True)
+
+    def _space_name_to_src(self, space) -> str | None:
+        return huggingface_hub.space_info(space, token=self.hf_token).host  # type: ignore
+
+    def _get_config(self) -> dict:
+        r = requests.get(
+            urllib.parse.urljoin(self.src, utils.CONFIG_URL), headers=self.headers
+        )
+        if r.ok:
+            return r.json()
+        else:  # to support older versions of Gradio
+            r = requests.get(self.src, headers=self.headers)
+            # some basic regex to extract the config
+            result = re.search(r"window.gradio_config = (.*?);[\s]*</script>", r.text)
+            try:
+                config = json.loads(result.group(1))  # type: ignore
+            except AttributeError as ae:
+                raise ValueError(
+                    f"Could not get Gradio config from: {self.src}"
+                ) from ae
+            if "allow_flagging" in config:
+                raise ValueError(
+                    "Gradio 2.x is not supported by this client. Please upgrade your Gradio app to Gradio 3.x or higher."
+                )
+            return config
+
+
+class Endpoint:
+    """Helper class for storing all the information about a single API endpoint."""
+
+    def __init__(self, client: Client, fn_index: int, dependency: dict):
+        self.client: Client = client
+        self.fn_index = fn_index
+        self.dependency = dependency
+        api_name = dependency.get("api_name")
+        self.api_name: str | None = (
+            None if (api_name is None or api_name is False) else "/" + api_name
+        )
+        self.use_ws = self._use_websocket(self.dependency)
+        self.input_component_types = []
+        self.output_component_types = []
+        self.root_url = client.src + "/" if not client.src.endswith("/") else client.src
+        try:
+            # Only a real API endpoint if backend_fn is True (so not just a frontend function), serializers are valid,
+            # and api_name is not False (meaning that the developer has explicitly disabled the API endpoint)
+            self.serializers, self.deserializers = self._setup_serializers()
+            self.is_valid = self.dependency["backend_fn"] and self.api_name is not False
+        except AssertionError:
+            self.is_valid = False
+
+    def __repr__(self):
+        return f"Endpoint src: {self.client.src}, api_name: {self.api_name}, fn_index: {self.fn_index}"
+
+    def __str__(self):
+        return self.__repr__()
+
+    def make_end_to_end_fn(self, helper: Communicator | None = None):
+        _predict = self.make_predict(helper)
+
+        def _inner(*data):
+            if not self.is_valid:
+                raise utils.InvalidAPIEndpointError()
+            data = self.insert_state(*data)
+            if self.client.serialize:
+                data = self.serialize(*data)
+            predictions = _predict(*data)
+            predictions = self.process_predictions(*predictions)
+            # Append final output only if not already present
+            # for consistency between generators and not generators
+            if helper:
+                with helper.lock:
+                    if not helper.job.outputs:
+                        helper.job.outputs.append(predictions)
+            return predictions
+
+        return _inner
+
+    def make_predict(self, helper: Communicator | None = None):
+        def _predict(*data) -> tuple:
+            data = json.dumps(
+                {
+                    "data": data,
+                    "fn_index": self.fn_index,
+                    "session_hash": self.client.session_hash,
+                }
+            )
+            hash_data = json.dumps(
+                {
+                    "fn_index": self.fn_index,
+                    "session_hash": self.client.session_hash,
+                }
+            )
+
+            if self.use_ws:
+                result = utils.synchronize_async(self._ws_fn, data, hash_data, helper)
+                if "error" in result:
+                    raise ValueError(result["error"])
+            else:
+                response = requests.post(
+                    self.client.api_url, headers=self.client.headers, data=data
+                )
+                result = json.loads(response.content.decode("utf-8"))
+            try:
+                output = result["data"]
+            except KeyError as ke:
+                is_public_space = (
+                    self.client.space_id
+                    and not huggingface_hub.space_info(self.client.space_id).private
+                )
+                if "error" in result and "429" in result["error"] and is_public_space:
+                    raise utils.TooManyRequestsError(
+                        f"Too many requests to the API, please try again later. To avoid being rate-limited, "
+                        f"please duplicate the Space using Client.duplicate({self.client.space_id}) "
+                        f"and pass in your Hugging Face token."
+                    ) from None
+                elif "error" in result:
+                    raise ValueError(result["error"]) from None
+                raise KeyError(
+                    f"Could not find 'data' key in response. Response received: {result}"
+                ) from ke
+            return tuple(output)
+
+        return _predict
+
+    def _predict_resolve(self, *data) -> Any:
+        """Needed for gradio.load(), which has a slightly different signature for serializing/deserializing"""
+        outputs = self.make_predict()(*data)
+        if len(self.dependency["outputs"]) == 1:
+            return outputs[0]
+        return outputs
+
+    def _upload(
+        self, file_paths: list[str | list[str]]
+    ) -> list[str | list[str]] | list[dict[str, Any] | list[dict[str, Any]]]:
+        if not file_paths:
+            return []
+        # Put all the filepaths in one file
+        # but then keep track of which index in the
+        # original list they came from so we can recreate
+        # the original structure
+        files = []
+        indices = []
+        for i, fs in enumerate(file_paths):
+            if not isinstance(fs, list):
+                fs = [fs]
+            for f in fs:
+                files.append(("files", (Path(f).name, open(f, "rb"))))  # noqa: SIM115
+                indices.append(i)
+        r = requests.post(
+            self.client.upload_url, headers=self.client.headers, files=files
+        )
+        if r.status_code != 200:
+            uploaded = file_paths
+        else:
+            uploaded = []
+            result = r.json()
+            for i, fs in enumerate(file_paths):
+                if isinstance(fs, list):
+                    output = [o for ix, o in enumerate(result) if indices[ix] == i]
+                    res = [
+                        {
+                            "is_file": True,
+                            "name": o,
+                            "orig_name": Path(f).name,
+                            "data": None,
+                        }
+                        for f, o in zip(fs, output)
+                    ]
+                else:
+                    o = next(o for ix, o in enumerate(result) if indices[ix] == i)
+                    res = {
+                        "is_file": True,
+                        "name": o,
+                        "orig_name": Path(fs).name,
+                        "data": None,
+                    }
+                uploaded.append(res)
+        return uploaded
+
+    def _add_uploaded_files_to_data(
+        self,
+        files: list[str | list[str]] | list[dict[str, Any] | list[dict[str, Any]]],
+        data: list[Any],
+    ) -> None:
+        """Helper function to modify the input data with the uploaded files."""
+        file_counter = 0
+        for i, t in enumerate(self.input_component_types):
+            if t in ["file", "uploadbutton"]:
+                data[i] = files[file_counter]
+                file_counter += 1
+
+    def insert_state(self, *data) -> tuple:
+        data = list(data)
+        for i, input_component_type in enumerate(self.input_component_types):
+            if input_component_type == utils.STATE_COMPONENT:
+                data.insert(i, None)
+        return tuple(data)
+
+    def remove_state(self, *data) -> tuple:
+        data = [
+            d
+            for d, oct in zip(data, self.output_component_types)
+            if oct != utils.STATE_COMPONENT
+        ]
+        return tuple(data)
+
+    def reduce_singleton_output(self, *data) -> Any:
+        if (
+            len(
+                [
+                    oct
+                    for oct in self.output_component_types
+                    if oct != utils.STATE_COMPONENT
+                ]
+            )
+            == 1
+        ):
+            return data[0]
+        else:
+            return data
+
+    def serialize(self, *data) -> tuple:
+        assert len(data) == len(
+            self.serializers
+        ), f"Expected {len(self.serializers)} arguments, got {len(data)}"
+
+        files = [
+            f
+            for f, t in zip(data, self.input_component_types)
+            if t in ["file", "uploadbutton"]
+        ]
+        uploaded_files = self._upload(files)
+        data = list(data)
+        self._add_uploaded_files_to_data(uploaded_files, data)
+        o = tuple([s.serialize(d) for s, d in zip(self.serializers, data)])
+        return o
+
+    def deserialize(self, *data) -> tuple:
+        assert len(data) == len(
+            self.deserializers
+        ), f"Expected {len(self.deserializers)} outputs, got {len(data)}"
+        outputs = tuple(
+            [
+                s.deserialize(
+                    d,
+                    save_dir=self.client.output_dir,
+                    hf_token=self.client.hf_token,
+                    root_url=self.root_url,
+                )
+                for s, d in zip(self.deserializers, data)
+            ]
+        )
+        return outputs
+
+    def process_predictions(self, *predictions):
+        if self.client.serialize:
+            predictions = self.deserialize(*predictions)
+        predictions = self.remove_state(*predictions)
+        predictions = self.reduce_singleton_output(*predictions)
+        return predictions
+
+    def _setup_serializers(self) -> tuple[list[Serializable], list[Serializable]]:
+        inputs = self.dependency["inputs"]
+        serializers = []
+
+        for i in inputs:
+            for component in self.client.config["components"]:
+                if component["id"] == i:
+                    component_name = component["type"]
+                    self.input_component_types.append(component_name)
+                    if component.get("serializer"):
+                        serializer_name = component["serializer"]
+                        assert (
+                            serializer_name in serializing.SERIALIZER_MAPPING
+                        ), f"Unknown serializer: {serializer_name}, you may need to update your gradio_client version."
+                        serializer = serializing.SERIALIZER_MAPPING[serializer_name]
+                    else:
+                        assert (
+                            component_name in serializing.COMPONENT_MAPPING
+                        ), f"Unknown component: {component_name}, you may need to update your gradio_client version."
+                        serializer = serializing.COMPONENT_MAPPING[component_name]
+                    serializers.append(serializer())  # type: ignore
+
+        outputs = self.dependency["outputs"]
+        deserializers = []
+        for i in outputs:
+            for component in self.client.config["components"]:
+                if component["id"] == i:
+                    component_name = component["type"]
+                    self.output_component_types.append(component_name)
+                    if component.get("serializer"):
+                        serializer_name = component["serializer"]
+                        assert (
+                            serializer_name in serializing.SERIALIZER_MAPPING
+                        ), f"Unknown serializer: {serializer_name}, you may need to update your gradio_client version."
+                        deserializer = serializing.SERIALIZER_MAPPING[serializer_name]
+                    else:
+                        assert (
+                            component_name in serializing.COMPONENT_MAPPING
+                        ), f"Unknown component: {component_name}, you may need to update your gradio_client version."
+                        deserializer = serializing.COMPONENT_MAPPING[component_name]
+                    deserializers.append(deserializer())  # type: ignore
+
+        return serializers, deserializers
+
+    def _use_websocket(self, dependency: dict) -> bool:
+        queue_enabled = self.client.config.get("enable_queue", False)
+        queue_uses_websocket = version.parse(
+            self.client.config.get("version", "2.0")
+        ) >= version.Version("3.2")
+        dependency_uses_queue = dependency.get("queue", False) is not False
+        return queue_enabled and queue_uses_websocket and dependency_uses_queue
+
+    async def _ws_fn(self, data, hash_data, helper: Communicator):
+        async with websockets.connect(  # type: ignore
+            self.client.ws_url,
+            open_timeout=10,
+            extra_headers=self.client.headers,
+            max_size=1024 * 1024 * 1024,
+        ) as websocket:
+            return await utils.get_pred_from_ws(websocket, data, hash_data, helper)
+
+
+@document("result", "outputs", "status")
+class Job(Future):
+    """
+    A Job is a wrapper over the Future class that represents a prediction call that has been
+    submitted by the Gradio client. This class is not meant to be instantiated directly, but rather
+    is created by the Client.submit() method.
+
+    A Job object includes methods to get the status of the prediction call, as well to get the outputs of
+    the prediction call. Job objects are also iterable, and can be used in a loop to get the outputs
+    of prediction calls as they become available for generator endpoints.
+    """
+
+    def __init__(
+        self,
+        future: Future,
+        communicator: Communicator | None = None,
+        verbose: bool = True,
+        space_id: str | None = None,
+    ):
+        """
+        Parameters:
+            future: The future object that represents the prediction call, created by the Client.submit() method
+            communicator: The communicator object that is used to communicate between the client and the background thread running the job
+            verbose: Whether to print any status-related messages to the console
+            space_id: The space ID corresponding to the Client object that created this Job object
+        """
+        self.future = future
+        self.communicator = communicator
+        self._counter = 0
+        self.verbose = verbose
+        self.space_id = space_id
+
+    def __iter__(self) -> Job:
+        return self
+
+    def __next__(self) -> tuple | Any:
+        if not self.communicator:
+            raise StopIteration()
+
+        with self.communicator.lock:
+            if self.communicator.job.latest_status.code == Status.FINISHED:
+                raise StopIteration()
+
+        while True:
+            with self.communicator.lock:
+                if len(self.communicator.job.outputs) == self._counter + 1:
+                    o = self.communicator.job.outputs[self._counter]
+                    self._counter += 1
+                    return o
+                if self.communicator.job.latest_status.code == Status.FINISHED:
+                    raise StopIteration()
+
+    def result(self, timeout: float | None = None) -> Any:
+        """
+        Return the result of the call that the future represents. Raises CancelledError: If the future was cancelled, TimeoutError: If the future didn't finish executing before the given timeout, and Exception: If the call raised then that exception will be raised.
+
+        Parameters:
+            timeout: The number of seconds to wait for the result if the future isn't done. If None, then there is no limit on the wait time.
+        Returns:
+            The result of the call that the future represents.
+        Example:
+            from gradio_client import Client
+            calculator = Client(src="gradio/calculator")
+            job = calculator.submit("foo", "add", 4, fn_index=0)
+            job.result(timeout=5)
+            >> 9
+        """
+        if self.communicator:
+            timeout = timeout or float("inf")
+            if self.future._exception:  # type: ignore
+                raise self.future._exception  # type: ignore
+            with self.communicator.lock:
+                if self.communicator.job.outputs:
+                    return self.communicator.job.outputs[0]
+            start = datetime.now()
+            while True:
+                if (datetime.now() - start).seconds > timeout:
+                    raise TimeoutError()
+                if self.future._exception:  # type: ignore
+                    raise self.future._exception  # type: ignore
+                with self.communicator.lock:
+                    if self.communicator.job.outputs:
+                        return self.communicator.job.outputs[0]
+                time.sleep(0.01)
+        else:
+            return super().result(timeout=timeout)
+
+    def outputs(self) -> list[tuple | Any]:
+        """
+        Returns a list containing the latest outputs from the Job.
+
+        If the endpoint has multiple output components, the list will contain
+        a tuple of results. Otherwise, it will contain the results without storing them
+        in tuples.
+
+        For endpoints that are queued, this list will contain the final job output even
+        if that endpoint does not use a generator function.
+
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/count_generator")
+            job = client.submit(3, api_name="/count")
+            while not job.done():
+                time.sleep(0.1)
+            job.outputs()
+            >> ['0', '1', '2']
+        """
+        if not self.communicator:
+            return []
+        else:
+            with self.communicator.lock:
+                return self.communicator.job.outputs
+
+    def status(self) -> StatusUpdate:
+        """
+        Returns the latest status update from the Job in the form of a StatusUpdate
+        object, which contains the following fields: code, rank, queue_size, success, time, eta, and progress_data.
+
+        progress_data is a list of updates emitted by the gr.Progress() tracker of the event handler. Each element
+        of the list has the following fields: index, length, unit, progress, desc. If the event handler does not have
+        a gr.Progress() tracker, the progress_data field will be None.
+
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            job = client.submit(5, "add", 4, api_name="/predict")
+            job.status()
+            >> <Status.STARTING: 'STARTING'>
+            job.status().eta
+            >> 43.241  # seconds
+        """
+        time = datetime.now()
+        cancelled = False
+        if self.communicator:
+            with self.communicator.lock:
+                cancelled = self.communicator.should_cancel
+        if cancelled:
+            return StatusUpdate(
+                code=Status.CANCELLED,
+                rank=0,
+                queue_size=None,
+                success=False,
+                time=time,
+                eta=None,
+                progress_data=None,
+            )
+        if self.done():
+            if not self.future._exception:  # type: ignore
+                return StatusUpdate(
+                    code=Status.FINISHED,
+                    rank=0,
+                    queue_size=None,
+                    success=True,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+            else:
+                return StatusUpdate(
+                    code=Status.FINISHED,
+                    rank=0,
+                    queue_size=None,
+                    success=False,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+        else:
+            if not self.communicator:
+                return StatusUpdate(
+                    code=Status.PROCESSING,
+                    rank=0,
+                    queue_size=None,
+                    success=None,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+            else:
+                with self.communicator.lock:
+                    eta = self.communicator.job.latest_status.eta
+                    if self.verbose and self.space_id and eta and eta > 30:
+                        print(
+                            f"Due to heavy traffic on this app, the prediction will take approximately {int(eta)} seconds."
+                            f"For faster predictions without waiting in queue, you may duplicate the space using: Client.duplicate({self.space_id})"
+                        )
+                    return self.communicator.job.latest_status
+
+    def __getattr__(self, name):
+        """Forwards any properties to the Future class."""
+        return getattr(self.future, name)
+
+    def cancel(self) -> bool:
+        """Cancels the job as best as possible.
+
+        If the app you are connecting to has the gradio queue enabled, the job
+        will be cancelled locally as soon as possible. For apps that do not use the
+        queue, the job cannot be cancelled if it's been sent to the local executor
+        (for the time being).
+
+        Note: In general, this DOES not stop the process from running in the upstream server
+        except for the following situations:
+
+        1. If the job is queued upstream, it will be removed from the queue and the server will not run the job
+        2. If the job has iterative outputs, the job will finish as soon as the current iteration finishes running
+        3. If the job has not been picked up by the queue yet, the queue will not pick up the job
+        """
+        if self.communicator:
+            with self.communicator.lock:
+                self.communicator.should_cancel = True
+                return True
+        return self.future.cancel()

parrot/lib/python3.10/site-packages/gradio_client/data_classes.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+from typing_extensions import NotRequired
+
+
+class FileData(TypedDict):
+    name: str | None  # filename
+    data: str | None  # base64 encoded data
+    size: NotRequired[int | None]  # size in bytes
+    is_file: NotRequired[
+        bool
+    ]  # whether the data corresponds to a file or base64 encoded data
+    orig_name: NotRequired[str]  # original filename

parrot/lib/python3.10/site-packages/gradio_client/documentation.py

@@ -0,0 +1,266 @@
+"""Contains methods that generate documentation for Gradio functions and classes."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Callable
+
+classes_to_document = {}
+classes_inherit_documentation = {}
+documentation_group = None
+
+
+def set_documentation_group(m):
+    global documentation_group
+    documentation_group = m
+    if m not in classes_to_document:
+        classes_to_document[m] = []
+
+
+def extract_instance_attr_doc(cls, attr):
+    code = inspect.getsource(cls.__init__)
+    lines = [line.strip() for line in code.split("\n")]
+    i = None
+    for i, line in enumerate(lines):  # noqa: B007
+        if line.startswith("self." + attr + ":") or line.startswith(
+            "self." + attr + " ="
+        ):
+            break
+    assert i is not None, f"Could not find {attr} in {cls.__name__}"
+    start_line = lines.index('"""', i)
+    end_line = lines.index('"""', start_line + 1)
+    for j in range(i + 1, start_line):
+        assert not lines[j].startswith("self."), (
+            f"Found another attribute before docstring for {attr} in {cls.__name__}: "
+            + lines[j]
+            + "\n start:"
+            + lines[i]
+        )
+    doc_string = " ".join(lines[start_line + 1 : end_line])
+    return doc_string
+
+
+def document(*fns, inherit=False):
+    """
+    Defines the @document decorator which adds classes or functions to the Gradio
+    documentation at www.gradio.app/docs.
+
+    Usage examples:
+    - Put @document() above a class to document the class and its constructor.
+    - Put @document("fn1", "fn2") above a class to also document methods fn1 and fn2.
+    - Put @document("*fn3") with an asterisk above a class to document the instance attribute methods f3.
+    """
+
+    def inner_doc(cls):
+        global documentation_group
+        if inherit:
+            classes_inherit_documentation[cls] = None
+        classes_to_document[documentation_group].append((cls, fns))
+        return cls
+
+    return inner_doc
+
+
+def document_fn(fn: Callable, cls) -> tuple[str, list[dict], dict, str | None]:
+    """
+    Generates documentation for any function.
+    Parameters:
+        fn: Function to document
+    Returns:
+        description: General description of fn
+        parameters: A list of dicts for each parameter, storing data for the parameter name, annotation and doc
+        return: A dict storing data for the returned annotation and doc
+        example: Code for an example use of the fn
+    """
+    doc_str = inspect.getdoc(fn) or ""
+    doc_lines = doc_str.split("\n")
+    signature = inspect.signature(fn)
+    description, parameters, returns, examples = [], {}, [], []
+    mode = "description"
+    for line in doc_lines:
+        line = line.rstrip()
+        if line == "Parameters:":
+            mode = "parameter"
+        elif line.startswith("Example:"):
+            mode = "example"
+            if "(" in line and ")" in line:
+                c = line.split("(")[1].split(")")[0]
+                if c != cls.__name__:
+                    mode = "ignore"
+        elif line == "Returns:":
+            mode = "return"
+        else:
+            if mode == "description":
+                description.append(line if line.strip() else "<br>")
+                continue
+            if not (line.startswith("    ") or line.strip() == ""):
+                print(line)
+            assert (
+                line.startswith("    ") or line.strip() == ""
+            ), f"Documentation format for {fn.__name__} has format error in line: {line}"
+            line = line[4:]
+            if mode == "parameter":
+                colon_index = line.index(": ")
+                assert (
+                    colon_index > -1
+                ), f"Documentation format for {fn.__name__} has format error in line: {line}"
+                parameter = line[:colon_index]
+                parameter_doc = line[colon_index + 2 :]
+                parameters[parameter] = parameter_doc
+            elif mode == "return":
+                returns.append(line)
+            elif mode == "example":
+                examples.append(line)
+    description_doc = " ".join(description)
+    parameter_docs = []
+    for param_name, param in signature.parameters.items():
+        if param_name.startswith("_"):
+            continue
+        if param_name in ["kwargs", "args"] and param_name not in parameters:
+            continue
+        parameter_doc = {
+            "name": param_name,
+            "annotation": param.annotation,
+            "doc": parameters.get(param_name),
+        }
+        if param_name in parameters:
+            del parameters[param_name]
+        if param.default != inspect.Parameter.empty:
+            default = param.default
+            if type(default) == str:
+                default = '"' + default + '"'
+            if default.__class__.__module__ != "builtins":
+                default = f"{default.__class__.__name__}()"
+            parameter_doc["default"] = default
+        elif parameter_doc["doc"] is not None:
+            if "kwargs" in parameter_doc["doc"]:
+                parameter_doc["kwargs"] = True
+            if "args" in parameter_doc["doc"]:
+                parameter_doc["args"] = True
+        parameter_docs.append(parameter_doc)
+    assert (
+        len(parameters) == 0
+    ), f"Documentation format for {fn.__name__} documents nonexistent parameters: {''.join(parameters.keys())}"
+    if len(returns) == 0:
+        return_docs = {}
+    elif len(returns) == 1:
+        return_docs = {"annotation": signature.return_annotation, "doc": returns[0]}
+    else:
+        return_docs = {}
+        # raise ValueError("Does not support multiple returns yet.")
+    examples_doc = "\n".join(examples) if len(examples) > 0 else None
+    return description_doc, parameter_docs, return_docs, examples_doc
+
+
+def document_cls(cls):
+    doc_str = inspect.getdoc(cls)
+    if doc_str is None:
+        return "", {}, ""
+    tags = {}
+    description_lines = []
+    mode = "description"
+    for line in doc_str.split("\n"):
+        line = line.rstrip()
+        if line.endswith(":") and " " not in line:
+            mode = line[:-1].lower()
+            tags[mode] = []
+        elif line.split(" ")[0].endswith(":") and not line.startswith("    "):
+            tag = line[: line.index(":")].lower()
+            value = line[line.index(":") + 2 :]
+            tags[tag] = value
+        else:
+            if mode == "description":
+                description_lines.append(line if line.strip() else "<br>")
+            else:
+                assert (
+                    line.startswith("    ") or not line.strip()
+                ), f"Documentation format for {cls.__name__} has format error in line: {line}"
+                tags[mode].append(line[4:])
+    if "example" in tags:
+        example = "\n".join(tags["example"])
+        del tags["example"]
+    else:
+        example = None
+    for key, val in tags.items():
+        if isinstance(val, list):
+            tags[key] = "<br>".join(val)
+    description = " ".join(description_lines).replace("\n", "<br>")
+    return description, tags, example
+
+
+def generate_documentation():
+    documentation = {}
+    for mode, class_list in classes_to_document.items():
+        documentation[mode] = []
+        for cls, fns in class_list:
+            fn_to_document = cls if inspect.isfunction(cls) else cls.__init__
+            _, parameter_doc, return_doc, _ = document_fn(fn_to_document, cls)
+            cls_description, cls_tags, cls_example = document_cls(cls)
+            cls_documentation = {
+                "class": cls,
+                "name": cls.__name__,
+                "description": cls_description,
+                "tags": cls_tags,
+                "parameters": parameter_doc,
+                "returns": return_doc,
+                "example": cls_example,
+                "fns": [],
+            }
+            for fn_name in fns:
+                instance_attribute_fn = fn_name.startswith("*")
+                if instance_attribute_fn:
+                    fn_name = fn_name[1:]
+                    # Instance attribute fns are classes
+                    # whose __call__ method determines their behavior
+                    fn = getattr(cls(), fn_name).__call__
+                else:
+                    fn = getattr(cls, fn_name)
+                if not callable(fn):
+                    description_doc = str(fn)
+                    parameter_docs = {}
+                    return_docs = {}
+                    examples_doc = ""
+                    override_signature = f"gr.{cls.__name__}.{fn_name}"
+                else:
+                    (
+                        description_doc,
+                        parameter_docs,
+                        return_docs,
+                        examples_doc,
+                    ) = document_fn(fn, cls)
+                    override_signature = None
+                if instance_attribute_fn:
+                    description_doc = extract_instance_attr_doc(cls, fn_name)
+                cls_documentation["fns"].append(
+                    {
+                        "fn": fn,
+                        "name": fn_name,
+                        "description": description_doc,
+                        "tags": {},
+                        "parameters": parameter_docs,
+                        "returns": return_docs,
+                        "example": examples_doc,
+                        "override_signature": override_signature,
+                    }
+                )
+            documentation[mode].append(cls_documentation)
+            if cls in classes_inherit_documentation:
+                classes_inherit_documentation[cls] = cls_documentation["fns"]
+    for mode, class_list in classes_to_document.items():
+        for i, (cls, _) in enumerate(class_list):
+            for super_class in classes_inherit_documentation:
+                if (
+                    inspect.isclass(cls)
+                    and issubclass(cls, super_class)
+                    and cls != super_class
+                ):
+                    for inherited_fn in classes_inherit_documentation[super_class]:
+                        inherited_fn = dict(inherited_fn)
+                        try:
+                            inherited_fn["description"] = extract_instance_attr_doc(
+                                cls, inherited_fn["name"]
+                            )
+                        except (ValueError, AssertionError):
+                            pass
+                        documentation[mode][i]["fns"].append(inherited_fn)
+    return documentation

parrot/lib/python3.10/site-packages/gradio_client/serializing.py

@@ -0,0 +1,550 @@
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+from gradio_client import media_data, utils
+from gradio_client.data_classes import FileData
+
+with open(Path(__file__).parent / "types.json") as f:
+    serializer_types = json.load(f)
+
+
+class Serializable:
+    def serialized_info(self):
+        """
+        The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+        Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+        """
+        return self.api_info()
+
+    def api_info(self) -> dict[str, list[str]]:
+        """
+        The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+        Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+        """
+        raise NotImplementedError()
+
+    def example_inputs(self) -> dict[str, Any]:
+        """
+        The example inputs for this component as a dictionary whose values are example inputs compatible with this component.
+        Keys of the dictionary are: raw, serialized
+        """
+        raise NotImplementedError()
+
+    # For backwards compatibility
+    def input_api_info(self) -> tuple[str, str]:
+        api_info = self.api_info()
+        return (api_info["serialized_input"][0], api_info["serialized_input"][1])
+
+    # For backwards compatibility
+    def output_api_info(self) -> tuple[str, str]:
+        api_info = self.api_info()
+        return (api_info["serialized_output"][0], api_info["serialized_output"][1])
+
+    def serialize(self, x: Any, load_dir: str | Path = ""):
+        """
+        Convert data from human-readable format to serialized format for a browser.
+        """
+        return x
+
+    def deserialize(
+        self,
+        x: Any,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ):
+        """
+        Convert data from serialized format for a browser to human-readable format.
+        """
+        return x
+
+
+class SimpleSerializable(Serializable):
+    """General class that does not perform any serialization or deserialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["SimpleSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": None,
+            "serialized": None,
+        }
+
+
+class StringSerializable(Serializable):
+    """Expects a string as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["StringSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": "Howdy!",
+            "serialized": "Howdy!",
+        }
+
+
+class ListStringSerializable(Serializable):
+    """Expects a list of strings as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["ListStringSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": ["Howdy!", "Merhaba"],
+            "serialized": ["Howdy!", "Merhaba"],
+        }
+
+
+class BooleanSerializable(Serializable):
+    """Expects a boolean as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["BooleanSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": True,
+            "serialized": True,
+        }
+
+
+class NumberSerializable(Serializable):
+    """Expects a number (int/float) as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["NumberSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": 5,
+            "serialized": 5,
+        }
+
+
+class ImgSerializable(Serializable):
+    """Expects a base64 string as input/output which is serialized to a filepath."""
+
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to image"}
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {"info": serializer_types["ImgSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": media_data.BASE64_IMAGE,
+            "serialized": "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+        }
+
+    def serialize(
+        self,
+        x: str | None,
+        load_dir: str | Path = "",
+    ) -> str | None:
+        """
+        Convert from human-friendly version of a file (string filepath) to a serialized
+        representation (base64).
+        Parameters:
+            x: String path to file to serialize
+            load_dir: Path to directory containing x
+        """
+        if not x:
+            return None
+        if utils.is_http_url_like(x):
+            return utils.encode_url_to_base64(x)
+        return utils.encode_file_to_base64(Path(load_dir) / x)
+
+    def deserialize(
+        self,
+        x: str | None,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by save_dir
+        Parameters:
+            x: Base64 representation of image to deserialize into a string filepath
+            save_dir: Path to directory to save the deserialized image to
+            root_url: Ignored
+            hf_token: Ignored
+        """
+        if x is None or x == "":
+            return None
+        file = utils.decode_base64_to_file(x, dir=save_dir)
+        return file.name
+
+
+class FileSerializable(Serializable):
+    """Expects a dict with base64 representation of object as input/output which is serialized to a filepath."""
+
+    def serialized_info(self):
+        return self._single_file_serialized_info()
+
+    def _single_file_api_info(self):
+        return {
+            "info": serializer_types["SingleFileSerializable"],
+            "serialized_info": True,
+        }
+
+    def _single_file_serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to file"}
+
+    def _multiple_file_serialized_info(self):
+        return {
+            "type": "array",
+            "description": "List of filepath(s) or URL(s) to files",
+            "items": {"type": "string", "description": "filepath or URL to file"},
+        }
+
+    def _multiple_file_api_info(self):
+        return {
+            "info": serializer_types["MultipleFileSerializable"],
+            "serialized_info": True,
+        }
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return self._single_file_api_info()
+
+    def example_inputs(self) -> dict[str, Any]:
+        return self._single_file_example_inputs()
+
+    def _single_file_example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"is_file": False, "data": media_data.BASE64_FILE},
+            "serialized": "https://github.com/gradio-app/gradio/raw/main/test/test_files/sample_file.pdf",
+        }
+
+    def _multiple_file_example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": [{"is_file": False, "data": media_data.BASE64_FILE}],
+            "serialized": [
+                "https://github.com/gradio-app/gradio/raw/main/test/test_files/sample_file.pdf"
+            ],
+        }
+
+    def _serialize_single(
+        self, x: str | FileData | None, load_dir: str | Path = ""
+    ) -> FileData | None:
+        if x is None or isinstance(x, dict):
+            return x
+        if utils.is_http_url_like(x):
+            filename = x
+            size = None
+        else:
+            filename = str(Path(load_dir) / x)
+            size = Path(filename).stat().st_size
+        return {
+            "name": filename,
+            "data": utils.encode_url_or_file_to_base64(filename),
+            "orig_name": Path(filename).name,
+            "is_file": False,
+            "size": size,
+        }
+
+    def _deserialize_single(
+        self,
+        x: str | FileData | None,
+        save_dir: str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        if x is None:
+            return None
+        if isinstance(x, str):
+            file_name = utils.decode_base64_to_file(x, dir=save_dir).name
+        elif isinstance(x, dict):
+            if x.get("is_file"):
+                filepath = x.get("name")
+                assert filepath is not None, f"The 'name' field is missing in {x}"
+                if root_url is not None:
+                    file_name = utils.download_tmp_copy_of_file(
+                        root_url + "file=" + filepath,
+                        hf_token=hf_token,
+                        dir=save_dir,
+                    )
+                else:
+                    file_name = utils.create_tmp_copy_of_file(filepath, dir=save_dir)
+            else:
+                data = x.get("data")
+                assert data is not None, f"The 'data' field is missing in {x}"
+                file_name = utils.decode_base64_to_file(data, dir=save_dir).name
+        else:
+            raise ValueError(
+                f"A FileSerializable component can only deserialize a string or a dict, not a {type(x)}: {x}"
+            )
+        return file_name
+
+    def serialize(
+        self,
+        x: str | FileData | None | list[str | FileData | None],
+        load_dir: str | Path = "",
+    ) -> FileData | None | list[FileData | None]:
+        """
+        Convert from human-friendly version of a file (string filepath) to a
+        serialized representation (base64)
+        Parameters:
+            x: String path to file to serialize
+            load_dir: Path to directory containing x
+        """
+        if x is None or x == "":
+            return None
+        if isinstance(x, list):
+            return [self._serialize_single(f, load_dir=load_dir) for f in x]
+        else:
+            return self._serialize_single(x, load_dir=load_dir)
+
+    def deserialize(
+        self,
+        x: str | FileData | None | list[str | FileData | None],
+        save_dir: Path | str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None | list[str | None]:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by `save_dir`
+        Parameters:
+            x: Base64 representation of file to deserialize into a string filepath
+            save_dir: Path to directory to save the deserialized file to
+            root_url: If this component is loaded from an external Space, this is the URL of the Space.
+            hf_token: If this component is loaded from an external private Space, this is the access token for the Space
+        """
+        if x is None:
+            return None
+        if isinstance(save_dir, Path):
+            save_dir = str(save_dir)
+        if isinstance(x, list):
+            return [
+                self._deserialize_single(
+                    f, save_dir=save_dir, root_url=root_url, hf_token=hf_token
+                )
+                for f in x
+            ]
+        else:
+            return self._deserialize_single(
+                x, save_dir=save_dir, root_url=root_url, hf_token=hf_token
+            )
+
+
+class VideoSerializable(FileSerializable):
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to video file"}
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {"info": serializer_types["FileSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"is_file": False, "data": media_data.BASE64_VIDEO},
+            "serialized": "https://github.com/gradio-app/gradio/raw/main/test/test_files/video_sample.mp4",
+        }
+
+    def serialize(
+        self, x: str | None, load_dir: str | Path = ""
+    ) -> tuple[FileData | None, None]:
+        return (super().serialize(x, load_dir), None)  # type: ignore
+
+    def deserialize(
+        self,
+        x: tuple[FileData | None, FileData | None] | None,
+        save_dir: Path | str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | tuple[str | None, str | None] | None:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by `save_dir`
+        """
+        if isinstance(x, (tuple, list)):
+            assert len(x) == 2, f"Expected tuple of length 2. Received: {x}"
+            x_as_list = [x[0], x[1]]
+        else:
+            raise ValueError(f"Expected tuple of length 2. Received: {x}")
+        deserialized_file = super().deserialize(x_as_list, save_dir, root_url, hf_token)  # type: ignore
+        if isinstance(deserialized_file, list):
+            return deserialized_file[0]  # ignore subtitles
+
+
+class JSONSerializable(Serializable):
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath to JSON file"}
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {"info": serializer_types["JSONSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"a": 1, "b": 2},
+            "serialized": None,
+        }
+
+    def serialize(
+        self,
+        x: str | None,
+        load_dir: str | Path = "",
+    ) -> dict | list | None:
+        """
+        Convert from a a human-friendly version (string path to json file) to a
+        serialized representation (json string)
+        Parameters:
+            x: String path to json file to read to get json string
+            load_dir: Path to directory containing x
+        """
+        if x is None or x == "":
+            return None
+        return utils.file_to_json(Path(load_dir) / x)
+
+    def deserialize(
+        self,
+        x: str | dict | list,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        """
+        Convert from serialized representation (json string) to a human-friendly
+        version (string path to json file).  Optionally, save the file to the directory specified by `save_dir`
+        Parameters:
+            x: Json string
+            save_dir: Path to save the deserialized json file to
+            root_url: Ignored
+            hf_token: Ignored
+        """
+        if x is None:
+            return None
+        return utils.dict_or_str_to_json_file(x, dir=save_dir).name
+
+
+class GallerySerializable(Serializable):
+    def serialized_info(self):
+        return {
+            "type": "string",
+            "description": "path to directory with images and a file associating images with captions called captions.json",
+        }
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {
+            "info": serializer_types["GallerySerializable"],
+            "serialized_info": True,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": [media_data.BASE64_IMAGE] * 2,
+            "serialized": [
+                "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+            ]
+            * 2,
+        }
+
+    def serialize(
+        self, x: str | None, load_dir: str | Path = ""
+    ) -> list[list[str | None]] | None:
+        if x is None or x == "":
+            return None
+        files = []
+        captions_file = Path(x) / "captions.json"
+        with captions_file.open("r") as captions_json:
+            captions = json.load(captions_json)
+        for file_name, caption in captions.items():
+            img = FileSerializable().serialize(file_name)
+            files.append([img, caption])
+        return files
+
+    def deserialize(
+        self,
+        x: list[list[str | None]] | None,
+        save_dir: str = "",
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> None | str:
+        if x is None:
+            return None
+        gallery_path = Path(save_dir) / str(uuid.uuid4())
+        gallery_path.mkdir(exist_ok=True, parents=True)
+        captions = {}
+        for img_data in x:
+            if isinstance(img_data, (list, tuple)):
+                img_data, caption = img_data
+            else:
+                caption = None
+            name = FileSerializable().deserialize(
+                img_data, gallery_path, root_url=root_url, hf_token=hf_token
+            )
+            captions[name] = caption
+            captions_file = gallery_path / "captions.json"
+            with captions_file.open("w") as captions_json:
+                json.dump(captions, captions_json)
+        return os.path.abspath(gallery_path)
+
+
+SERIALIZER_MAPPING = {}
+for cls in Serializable.__subclasses__():
+    SERIALIZER_MAPPING[cls.__name__] = cls
+    for subcls in cls.__subclasses__():
+        SERIALIZER_MAPPING[subcls.__name__] = subcls
+
+SERIALIZER_MAPPING["Serializable"] = SimpleSerializable
+SERIALIZER_MAPPING["File"] = FileSerializable
+SERIALIZER_MAPPING["UploadButton"] = FileSerializable
+
+COMPONENT_MAPPING: dict[str, type] = {
+    "textbox": StringSerializable,
+    "number": NumberSerializable,
+    "slider": NumberSerializable,
+    "checkbox": BooleanSerializable,
+    "checkboxgroup": ListStringSerializable,
+    "radio": StringSerializable,
+    "dropdown": SimpleSerializable,
+    "image": ImgSerializable,
+    "video": FileSerializable,
+    "audio": FileSerializable,
+    "file": FileSerializable,
+    "dataframe": JSONSerializable,
+    "timeseries": JSONSerializable,
+    "state": SimpleSerializable,
+    "button": StringSerializable,
+    "uploadbutton": FileSerializable,
+    "colorpicker": StringSerializable,
+    "label": JSONSerializable,
+    "highlightedtext": JSONSerializable,
+    "json": JSONSerializable,
+    "html": StringSerializable,
+    "gallery": GallerySerializable,
+    "chatbot": JSONSerializable,
+    "model3d": FileSerializable,
+    "plot": JSONSerializable,
+    "barplot": JSONSerializable,
+    "lineplot": JSONSerializable,
+    "scatterplot": JSONSerializable,
+    "markdown": StringSerializable,
+    "dataset": StringSerializable,
+    "code": StringSerializable,
+    "interpretation": SimpleSerializable,
+    "annotatedimage": JSONSerializable,
+}

parrot/lib/python3.10/site-packages/gradio_client/types.json

@@ -0,0 +1,199 @@
+{
+	"SimpleSerializable": {
+		"type": {},
+		"description": "any valid value"
+	},
+	"StringSerializable": {
+		"type": "string"
+	},
+	"ListStringSerializable": {
+		"type": "array",
+		"items": {
+			"type": "string"
+		}
+	},
+	"BooleanSerializable": {
+		"type": "boolean"
+	},
+	"NumberSerializable": {
+		"type": "number"
+	},
+	"ImgSerializable": {
+		"type": "string",
+		"description": "base64 representation of an image"
+	},
+	"FileSerializable": {
+		"oneOf": [
+			{
+				"type": "string",
+				"description": "filepath or URL to file"
+			},
+			{
+				"type": "object",
+				"properties": {
+					"name": { "type": "string", "description": "name of file" },
+					"data": {
+						"type": "string",
+						"description": "base64 representation of file"
+					},
+					"size": {
+						"type": "integer",
+						"description": "size of image in bytes"
+					},
+					"is_file": {
+						"type": "boolean",
+						"description": "true if the file has been uploaded to the server"
+					},
+					"orig_name": {
+						"type": "string",
+						"description": "original name of the file"
+					}
+				},
+				"required": ["name", "data"]
+			},
+			{
+				"type": "array",
+				"items": {
+					"anyOf": [
+						{
+							"type": "string",
+							"description": "filepath or URL to file"
+						},
+						{
+							"type": "object",
+							"properties": {
+								"name": { "type": "string", "description": "name of file" },
+								"data": {
+									"type": "string",
+									"description": "base64 representation of file"
+								},
+								"size": {
+									"type": "integer",
+									"description": "size of image in bytes"
+								},
+								"is_file": {
+									"type": "boolean",
+									"description": "true if the file has been uploaded to the server"
+								},
+								"orig_name": {
+									"type": "string",
+									"description": "original name of the file"
+								}
+							},
+							"required": ["name", "data"]
+						}
+					]
+				}
+			}
+		]
+	},
+	"SingleFileSerializable": {
+		"oneOf": [
+			{
+				"type": "string",
+				"description": "filepath or URL to file"
+			},
+			{
+				"type": "object",
+				"properties": {
+					"name": { "type": "string", "description": "name of file" },
+					"data": {
+						"type": "string",
+						"description": "base64 representation of file"
+					},
+					"size": {
+						"type": "integer",
+						"description": "size of image in bytes"
+					},
+					"is_file": {
+						"type": "boolean",
+						"description": "true if the file has been uploaded to the server"
+					},
+					"orig_name": {
+						"type": "string",
+						"description": "original name of the file"
+					}
+				},
+				"required": ["name", "data"]
+			}
+		]
+	},
+	"MultipleFileSerializable": {
+		"type": "array",
+		"items": {
+			"anyOf": [
+				{
+					"type": "string",
+					"description": "filepath or URL to file"
+				},
+				{
+					"type": "object",
+					"properties": {
+						"name": { "type": "string", "description": "name of file" },
+						"data": {
+							"type": "string",
+							"description": "base64 representation of file"
+						},
+						"size": {
+							"type": "integer",
+							"description": "size of image in bytes"
+						},
+						"is_file": {
+							"type": "boolean",
+							"description": "true if the file has been uploaded to the server"
+						},
+						"orig_name": {
+							"type": "string",
+							"description": "original name of the file"
+						}
+					},
+					"required": ["name", "data"]
+				}
+			]
+		}
+	},
+	"JSONSerializable": {
+		"type": {},
+		"description": "any valid json"
+	},
+	"GallerySerializable": {
+		"type": "array",
+		"items": {
+			"type": "array",
+			"items": false,
+			"maxSize": 2,
+			"minSize": 2,
+			"prefixItems": [
+				{
+					"type": "object",
+					"properties": {
+						"name": { "type": "string", "description": "name of file" },
+						"data": {
+							"type": "string",
+							"description": "base64 representation of file"
+						},
+						"size": {
+							"type": "integer",
+							"description": "size of image in bytes"
+						},
+						"is_file": {
+							"type": "boolean",
+							"description": "true if the file has been uploaded to the server"
+						},
+						"orig_name": {
+							"type": "string",
+							"description": "original name of the file"
+						}
+					},
+					"required": ["name", "data"]
+				},
+				{
+					"oneOf": [
+						{ "type": "string", "description": "caption of image" },
+						{ "type": "null" }
+					]
+				}
+			]
+		}
+	}
+}

parrot/lib/python3.10/site-packages/gradio_client/utils.py

@@ -0,0 +1,561 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import mimetypes
+import os
+import pkgutil
+import secrets
+import shutil
+import tempfile
+import warnings
+from concurrent.futures import CancelledError
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Optional
+
+import fsspec.asyn
+import httpx
+import huggingface_hub
+import requests
+from huggingface_hub import SpaceStage
+from websockets.legacy.protocol import WebSocketCommonProtocol
+
+API_URL = "api/predict/"
+WS_URL = "queue/join"
+UPLOAD_URL = "upload"
+CONFIG_URL = "config"
+API_INFO_URL = "info"
+RAW_API_INFO_URL = "info?serialize=False"
+SPACE_FETCHER_URL = "https://gradio-space-api-fetcher-v2.hf.space/api"
+RESET_URL = "reset"
+SPACE_URL = "https://hf.space/{}"
+
+STATE_COMPONENT = "state"
+INVALID_RUNTIME = [
+    SpaceStage.NO_APP_FILE,
+    SpaceStage.CONFIG_ERROR,
+    SpaceStage.BUILD_ERROR,
+    SpaceStage.RUNTIME_ERROR,
+    SpaceStage.PAUSED,
+]
+
+__version__ = (pkgutil.get_data(__name__, "version.txt") or b"").decode("ascii").strip()
+
+
+class TooManyRequestsError(Exception):
+    """Raised when the API returns a 429 status code."""
+
+    pass
+
+
+class QueueError(Exception):
+    """Raised when the queue is full or there is an issue adding a job to the queue."""
+
+    pass
+
+
+class InvalidAPIEndpointError(Exception):
+    """Raised when the API endpoint is invalid."""
+
+    pass
+
+
+class SpaceDuplicationError(Exception):
+    """Raised when something goes wrong with a Space Duplication."""
+
+    pass
+
+
+class Status(Enum):
+    """Status codes presented to client users."""
+
+    STARTING = "STARTING"
+    JOINING_QUEUE = "JOINING_QUEUE"
+    QUEUE_FULL = "QUEUE_FULL"
+    IN_QUEUE = "IN_QUEUE"
+    SENDING_DATA = "SENDING_DATA"
+    PROCESSING = "PROCESSING"
+    ITERATING = "ITERATING"
+    PROGRESS = "PROGRESS"
+    FINISHED = "FINISHED"
+    CANCELLED = "CANCELLED"
+
+    @staticmethod
+    def ordering(status: Status) -> int:
+        """Order of messages. Helpful for testing."""
+        order = [
+            Status.STARTING,
+            Status.JOINING_QUEUE,
+            Status.QUEUE_FULL,
+            Status.IN_QUEUE,
+            Status.SENDING_DATA,
+            Status.PROCESSING,
+            Status.PROGRESS,
+            Status.ITERATING,
+            Status.FINISHED,
+            Status.CANCELLED,
+        ]
+        return order.index(status)
+
+    def __lt__(self, other: Status):
+        return self.ordering(self) < self.ordering(other)
+
+    @staticmethod
+    def msg_to_status(msg: str) -> Status:
+        """Map the raw message from the backend to the status code presented to users."""
+        return {
+            "send_hash": Status.JOINING_QUEUE,
+            "queue_full": Status.QUEUE_FULL,
+            "estimation": Status.IN_QUEUE,
+            "send_data": Status.SENDING_DATA,
+            "process_starts": Status.PROCESSING,
+            "process_generating": Status.ITERATING,
+            "process_completed": Status.FINISHED,
+            "progress": Status.PROGRESS,
+        }[msg]
+
+
+@dataclass
+class ProgressUnit:
+    index: Optional[int]
+    length: Optional[int]
+    unit: Optional[str]
+    progress: Optional[float]
+    desc: Optional[str]
+
+    @classmethod
+    def from_ws_msg(cls, data: list[dict]) -> list[ProgressUnit]:
+        return [
+            cls(
+                index=d.get("index"),
+                length=d.get("length"),
+                unit=d.get("unit"),
+                progress=d.get("progress"),
+                desc=d.get("desc"),
+            )
+            for d in data
+        ]
+
+
+@dataclass
+class StatusUpdate:
+    """Update message sent from the worker thread to the Job on the main thread."""
+
+    code: Status
+    rank: int | None
+    queue_size: int | None
+    eta: float | None
+    success: bool | None
+    time: datetime | None
+    progress_data: list[ProgressUnit] | None
+
+
+def create_initial_status_update():
+    return StatusUpdate(
+        code=Status.STARTING,
+        rank=None,
+        queue_size=None,
+        eta=None,
+        success=None,
+        time=datetime.now(),
+        progress_data=None,
+    )
+
+
+@dataclass
+class JobStatus:
+    """The job status.
+
+    Keeps track of the latest status update and intermediate outputs (not yet implements).
+    """
+
+    latest_status: StatusUpdate = field(default_factory=create_initial_status_update)
+    outputs: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class Communicator:
+    """Helper class to help communicate between the worker thread and main thread."""
+
+    lock: Lock
+    job: JobStatus
+    prediction_processor: Callable[..., tuple]
+    reset_url: str
+    should_cancel: bool = False
+
+
+########################
+# Network utils
+########################
+
+
+def is_http_url_like(possible_url: str) -> bool:
+    """
+    Check if the given string looks like an HTTP(S) URL.
+    """
+    return possible_url.startswith(("http://", "https://"))
+
+
+def probe_url(possible_url: str) -> bool:
+    """
+    Probe the given URL to see if it responds with a 200 status code (to HEAD, then to GET).
+    """
+    headers = {"User-Agent": "gradio (https://gradio.app/; team@gradio.app)"}
+    try:
+        with requests.session() as sess:
+            head_request = sess.head(possible_url, headers=headers)
+            if head_request.status_code == 405:
+                return sess.get(possible_url, headers=headers).ok
+            return head_request.ok
+    except Exception:
+        return False
+
+
+def is_valid_url(possible_url: str) -> bool:
+    """
+    Check if the given string is a valid URL.
+    """
+    warnings.warn(
+        "is_valid_url should not be used. "
+        "Use is_http_url_like() and probe_url(), as suitable, instead.",
+    )
+    return is_http_url_like(possible_url) and probe_url(possible_url)
+
+
+async def get_pred_from_ws(
+    websocket: WebSocketCommonProtocol,
+    data: str,
+    hash_data: str,
+    helper: Communicator | None = None,
+) -> dict[str, Any]:
+    completed = False
+    resp = {}
+    while not completed:
+        # Receive message in the background so that we can
+        # cancel even while running a long pred
+        task = asyncio.create_task(websocket.recv())
+        while not task.done():
+            if helper:
+                with helper.lock:
+                    if helper.should_cancel:
+                        # Need to reset the iterator state since the client
+                        # will not reset the session
+                        async with httpx.AsyncClient() as http:
+                            reset = http.post(
+                                helper.reset_url, json=json.loads(hash_data)
+                            )
+                            # Retrieve cancel exception from task
+                            # otherwise will get nasty warning in console
+                            task.cancel()
+                            await asyncio.gather(task, reset, return_exceptions=True)
+                        raise CancelledError()
+            # Need to suspend this coroutine so that task actually runs
+            await asyncio.sleep(0.01)
+        msg = task.result()
+        resp = json.loads(msg)
+        if helper:
+            with helper.lock:
+                has_progress = "progress_data" in resp
+                status_update = StatusUpdate(
+                    code=Status.msg_to_status(resp["msg"]),
+                    queue_size=resp.get("queue_size"),
+                    rank=resp.get("rank", None),
+                    success=resp.get("success"),
+                    time=datetime.now(),
+                    eta=resp.get("rank_eta"),
+                    progress_data=ProgressUnit.from_ws_msg(resp["progress_data"])
+                    if has_progress
+                    else None,
+                )
+                output = resp.get("output", {}).get("data", [])
+                if output and status_update.code != Status.FINISHED:
+                    try:
+                        result = helper.prediction_processor(*output)
+                    except Exception as e:
+                        result = [e]
+                    helper.job.outputs.append(result)
+                helper.job.latest_status = status_update
+        if resp["msg"] == "queue_full":
+            raise QueueError("Queue is full! Please try again.")
+        if resp["msg"] == "send_hash":
+            await websocket.send(hash_data)
+        elif resp["msg"] == "send_data":
+            await websocket.send(data)
+        completed = resp["msg"] == "process_completed"
+    return resp["output"]
+
+
+########################
+# Data processing utils
+########################
+
+
+def download_tmp_copy_of_file(
+    url_path: str, hf_token: str | None = None, dir: str | None = None
+) -> str:
+    if dir is not None:
+        os.makedirs(dir, exist_ok=True)
+    headers = {"Authorization": "Bearer " + hf_token} if hf_token else {}
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    file_path = directory / Path(url_path).name
+
+    with requests.get(url_path, headers=headers, stream=True) as r:
+        r.raise_for_status()
+        with open(file_path, "wb") as f:
+            shutil.copyfileobj(r.raw, f)
+    return str(file_path.resolve())
+
+
+def create_tmp_copy_of_file(file_path: str, dir: str | None = None) -> str:
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    dest = directory / Path(file_path).name
+    shutil.copy2(file_path, dest)
+    return str(dest.resolve())
+
+
+def get_mimetype(filename: str) -> str | None:
+    if filename.endswith(".vtt"):
+        return "text/vtt"
+    mimetype = mimetypes.guess_type(filename)[0]
+    if mimetype is not None:
+        mimetype = mimetype.replace("x-wav", "wav").replace("x-flac", "flac")
+    return mimetype
+
+
+def get_extension(encoding: str) -> str | None:
+    encoding = encoding.replace("audio/wav", "audio/x-wav")
+    type = mimetypes.guess_type(encoding)[0]
+    if type == "audio/flac":  # flac is not supported by mimetypes
+        return "flac"
+    elif type is None:
+        return None
+    extension = mimetypes.guess_extension(type)
+    if extension is not None and extension.startswith("."):
+        extension = extension[1:]
+    return extension
+
+
+def encode_file_to_base64(f: str | Path):
+    with open(f, "rb") as file:
+        encoded_string = base64.b64encode(file.read())
+        base64_str = str(encoded_string, "utf-8")
+        mimetype = get_mimetype(str(f))
+        return (
+            "data:"
+            + (mimetype if mimetype is not None else "")
+            + ";base64,"
+            + base64_str
+        )
+
+
+def encode_url_to_base64(url: str):
+    resp = requests.get(url)
+    resp.raise_for_status()
+    encoded_string = base64.b64encode(resp.content)
+    base64_str = str(encoded_string, "utf-8")
+    mimetype = get_mimetype(url)
+    return (
+        "data:" + (mimetype if mimetype is not None else "") + ";base64," + base64_str
+    )
+
+
+def encode_url_or_file_to_base64(path: str | Path):
+    path = str(path)
+    if is_http_url_like(path):
+        return encode_url_to_base64(path)
+    return encode_file_to_base64(path)
+
+
+def decode_base64_to_binary(encoding: str) -> tuple[bytes, str | None]:
+    extension = get_extension(encoding)
+    data = encoding.rsplit(",", 1)[-1]
+    return base64.b64decode(data), extension
+
+
+def strip_invalid_filename_characters(filename: str, max_bytes: int = 200) -> str:
+    """Strips invalid characters from a filename and ensures that the file_length is less than `max_bytes` bytes."""
+    filename = "".join([char for char in filename if char.isalnum() or char in "._- "])
+    filename_len = len(filename.encode())
+    if filename_len > max_bytes:
+        while filename_len > max_bytes:
+            if len(filename) == 0:
+                break
+            filename = filename[:-1]
+            filename_len = len(filename.encode())
+    return filename
+
+
+def sanitize_parameter_names(original_name: str) -> str:
+    """Cleans up a Python parameter name to make the API info more readable."""
+    return (
+        "".join([char for char in original_name if char.isalnum() or char in " _"])
+        .replace(" ", "_")
+        .lower()
+    )
+
+
+def decode_base64_to_file(
+    encoding: str,
+    file_path: str | None = None,
+    dir: str | Path | None = None,
+    prefix: str | None = None,
+):
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    data, extension = decode_base64_to_binary(encoding)
+    if file_path is not None and prefix is None:
+        filename = Path(file_path).name
+        prefix = filename
+        if "." in filename:
+            prefix = filename[0 : filename.index(".")]
+            extension = filename[filename.index(".") + 1 :]
+
+    if prefix is not None:
+        prefix = strip_invalid_filename_characters(prefix)
+
+    if extension is None:
+        file_obj = tempfile.NamedTemporaryFile(
+            delete=False, prefix=prefix, dir=directory
+        )
+    else:
+        file_obj = tempfile.NamedTemporaryFile(
+            delete=False,
+            prefix=prefix,
+            suffix="." + extension,
+            dir=directory,
+        )
+    file_obj.write(data)
+    file_obj.flush()
+    return file_obj
+
+
+def dict_or_str_to_json_file(jsn: str | dict | list, dir: str | Path | None = None):
+    if dir is not None:
+        os.makedirs(dir, exist_ok=True)
+
+    file_obj = tempfile.NamedTemporaryFile(
+        delete=False, suffix=".json", dir=dir, mode="w+"
+    )
+    if isinstance(jsn, str):
+        jsn = json.loads(jsn)
+    json.dump(jsn, file_obj)
+    file_obj.flush()
+    return file_obj
+
+
+def file_to_json(file_path: str | Path) -> dict | list:
+    with open(file_path) as f:
+        return json.load(f)
+
+
+###########################
+# HuggingFace Hub API Utils
+###########################
+def set_space_timeout(
+    space_id: str,
+    hf_token: str | None = None,
+    timeout_in_seconds: int = 300,
+):
+    headers = huggingface_hub.utils.build_hf_headers(
+        token=hf_token,
+        library_name="gradio_client",
+        library_version=__version__,
+    )
+    req = requests.post(
+        f"https://huggingface.co/api/spaces/{space_id}/sleeptime",
+        json={"seconds": timeout_in_seconds},
+        headers=headers,
+    )
+    try:
+        huggingface_hub.utils.hf_raise_for_status(req)
+    except huggingface_hub.utils.HfHubHTTPError as err:
+        raise SpaceDuplicationError(
+            f"Could not set sleep timeout on duplicated Space. Please visit {SPACE_URL.format(space_id)} "
+            "to set a timeout manually to reduce billing charges."
+        ) from err
+
+
+########################
+# Misc utils
+########################
+
+
+def synchronize_async(func: Callable, *args, **kwargs) -> Any:
+    """
+    Runs async functions in sync scopes. Can be used in any scope.
+
+    Example:
+        if inspect.iscoroutinefunction(block_fn.fn):
+            predictions = utils.synchronize_async(block_fn.fn, *processed_input)
+
+    Args:
+        func:
+        *args:
+        **kwargs:
+    """
+    return fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args, **kwargs)  # type: ignore
+
+
+class APIInfoParseError(ValueError):
+    pass
+
+
+def get_type(schema: dict):
+    if "type" in schema:
+        return schema["type"]
+    elif schema.get("oneOf"):
+        return "oneOf"
+    elif schema.get("anyOf"):
+        return "anyOf"
+    else:
+        raise APIInfoParseError(f"Cannot parse type for {schema}")
+
+
+def json_schema_to_python_type(schema: Any) -> str:
+    """Convert the json schema into a python type hint"""
+    type_ = get_type(schema)
+    if type_ == {}:
+        if "json" in schema["description"]:
+            return "Dict[Any, Any]"
+        else:
+            return "Any"
+    elif type_ == "null":
+        return "None"
+    elif type_ == "integer":
+        return "int"
+    elif type_ == "string":
+        return "str"
+    elif type_ == "boolean":
+        return "bool"
+    elif type_ == "number":
+        return "int | float"
+    elif type_ == "array":
+        items = schema.get("items")
+        if "prefixItems" in items:
+            elements = ", ".join(
+                [json_schema_to_python_type(i) for i in items["prefixItems"]]
+            )
+            return f"Tuple[{elements}]"
+        else:
+            elements = json_schema_to_python_type(items)
+            return f"List[{elements}]"
+    elif type_ == "object":
+        des = ", ".join(
+            [
+                f"{n}: {json_schema_to_python_type(v)} ({v.get('description')})"
+                for n, v in schema["properties"].items()
+            ]
+        )
+        return f"Dict({des})"
+    elif type_ in ["oneOf", "anyOf"]:
+        desc = " | ".join([json_schema_to_python_type(i) for i in schema[type_]])
+        return desc
+    else:
+        raise APIInfoParseError(f"Cannot parse schema {schema}")

parrot/lib/python3.10/site-packages/gradio_client/version.txt

@@ -0,0 +1 @@
+0.2.9

parrot/lib/python3.10/site-packages/hjson-3.1.0.dist-info/RECORD

@@ -0,0 +1,77 @@
+../../../bin/hjson,sha256=BMDbBsC7xHTFEAmdzyvlziODAp-oO8mUkWoR1b0MkkI,221
+hjson-3.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+hjson-3.1.0.dist-info/LICENSE.txt,sha256=WRxR9JxoM7zhpdU-Y3haBGet1nRaWogOTRD05kzETEw,10462
+hjson-3.1.0.dist-info/METADATA,sha256=ws3nEqUXFpWNgmH-FYScGumUSgt2dkiPHNm7RZh-gcU,2610
+hjson-3.1.0.dist-info/RECORD,,
+hjson-3.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hjson-3.1.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+hjson-3.1.0.dist-info/entry_points.txt,sha256=sghBTcTrqdK0kKuznOZXeEBtjoBnLweHF83S9NK-r0E,42
+hjson-3.1.0.dist-info/top_level.txt,sha256=earxK7niVoW6ADlKRFHCs3JpUL4FBSnJn9qmrYgnEUE,6
+hjson/__init__.py,sha256=Py1drAVt-Xpi2xJAHxVXDdX-NniC4llxZVPjY7MyPCY,26580
+hjson/__pycache__/__init__.cpython-310.pyc,,
+hjson/__pycache__/compat.cpython-310.pyc,,
+hjson/__pycache__/decoder.cpython-310.pyc,,
+hjson/__pycache__/encoder.cpython-310.pyc,,
+hjson/__pycache__/encoderH.cpython-310.pyc,,
+hjson/__pycache__/ordered_dict.cpython-310.pyc,,
+hjson/__pycache__/scanner.cpython-310.pyc,,
+hjson/__pycache__/tool.cpython-310.pyc,,
+hjson/compat.py,sha256=uvmTYe1Oa18tT_6tFRtYnzTdAkyd73B9zwMF7ZafI04,1036
+hjson/decoder.py,sha256=oHz7g2sQd4S-AJbSzur9VJWqAHDWL25FVQ-G35XlGCA,19563
+hjson/encoder.py,sha256=NhR3YSMVzL3UP8OLAtP2Dr6dW9UbJzjVS-SXp1DzvcY,19168
+hjson/encoderH.py,sha256=wJ8D0gAyR3n6e3MahCIU3OahI5_xuHPWV_ZlI839xCs,20481
+hjson/ordered_dict.py,sha256=DXtgiqkkaNWXDLZ0DGXIjF_CPzGV5qpC-PSeS1zcps8,3370
+hjson/scanner.py,sha256=IL8poQGvCsb82y7qY5jrlSrZ5xcENpPUti3tNKhprYw,1779
+hjson/tests/__init__.py,sha256=_A-1Tn7q7ccNPro_QfbKiXo_bTL9ED5RUX9AeSLG4TA,2011
+hjson/tests/__pycache__/__init__.cpython-310.pyc,,
+hjson/tests/__pycache__/test_bigint_as_string.cpython-310.pyc,,
+hjson/tests/__pycache__/test_bitsize_int_as_string.cpython-310.pyc,,
+hjson/tests/__pycache__/test_check_circular.cpython-310.pyc,,
+hjson/tests/__pycache__/test_decimal.cpython-310.pyc,,
+hjson/tests/__pycache__/test_decode.cpython-310.pyc,,
+hjson/tests/__pycache__/test_default.cpython-310.pyc,,
+hjson/tests/__pycache__/test_dump.cpython-310.pyc,,
+hjson/tests/__pycache__/test_encode_basestring_ascii.cpython-310.pyc,,
+hjson/tests/__pycache__/test_errors.cpython-310.pyc,,
+hjson/tests/__pycache__/test_fail.cpython-310.pyc,,
+hjson/tests/__pycache__/test_float.cpython-310.pyc,,
+hjson/tests/__pycache__/test_for_json.cpython-310.pyc,,
+hjson/tests/__pycache__/test_hjson.cpython-310.pyc,,
+hjson/tests/__pycache__/test_indent.cpython-310.pyc,,
+hjson/tests/__pycache__/test_item_sort_key.cpython-310.pyc,,
+hjson/tests/__pycache__/test_namedtuple.cpython-310.pyc,,
+hjson/tests/__pycache__/test_pass1.cpython-310.pyc,,
+hjson/tests/__pycache__/test_pass2.cpython-310.pyc,,
+hjson/tests/__pycache__/test_pass3.cpython-310.pyc,,
+hjson/tests/__pycache__/test_recursion.cpython-310.pyc,,
+hjson/tests/__pycache__/test_scanstring.cpython-310.pyc,,
+hjson/tests/__pycache__/test_separators.cpython-310.pyc,,
+hjson/tests/__pycache__/test_tool.cpython-310.pyc,,
+hjson/tests/__pycache__/test_tuple.cpython-310.pyc,,
+hjson/tests/__pycache__/test_unicode.cpython-310.pyc,,
+hjson/tests/test_bigint_as_string.py,sha256=bhEtYEXWUhxyi25iLm4sPWFrt5RZ9PfFEknX1cdzP-Y,2265
+hjson/tests/test_bitsize_int_as_string.py,sha256=-73xJ8CE2hDjGOWTERRrYbDHaY0kgBNQXC0g8nIgd4k,2332
+hjson/tests/test_check_circular.py,sha256=64kZhsab6OcwYmJNLRqNW-19dp1UdgYbZiGzopKyR9s,940
+hjson/tests/test_decimal.py,sha256=Qw0IBPSPYoGZXwvXkkM1cz6lpqjkPRzNDBSul-RdR_4,2556
+hjson/tests/test_decode.py,sha256=Sm4052xVjv7ZtZFdRVMsnvQeh2eCNoXv24YOUJJLMdg,4437
+hjson/tests/test_default.py,sha256=WWDLhDVfih4PrenmiEcvshhUOl_bNsm3jML96-AtGmo,224
+hjson/tests/test_dump.py,sha256=5WU4Rd6vsHOwXGpGqQKIw1ZBNgRWUqMY8w3DnJVWfxo,5061
+hjson/tests/test_encode_basestring_ascii.py,sha256=up4y9JMdGXdBXkEjfqwiG-sudSdcKw0RQfO_76za-To,2102
+hjson/tests/test_errors.py,sha256=vg3-z36T9O-UeDHG4ZtW-nQBNAvraWKBrDA70yG989c,1549
+hjson/tests/test_fail.py,sha256=Giinb944NX0bPwBHYUjVZ4ZlNB611Wg0wxVWxv4bDaU,5688
+hjson/tests/test_float.py,sha256=LCUL-2xT8PYq99jQi6-Ddk9pMuC1mLrcJboTfvR08HM,1011
+hjson/tests/test_for_json.py,sha256=ZLtypdX0ALctxMB8c3fQvx3k9OHY5t71gBxGNOXemrc,2778
+hjson/tests/test_hjson.py,sha256=CdvXR05nu8bF_jZ-Hhj3bh8LRi8tdSJTruayj69HoDk,2327
+hjson/tests/test_indent.py,sha256=8oUK5E8DTz1c3RkUU-nOELmr9wOKoaHHOAsxDai66iE,2589
+hjson/tests/test_item_sort_key.py,sha256=piYy-ntwdcb_qS-y8jPFI6rVZlHCNqtTFGnaZSEvWH8,1134
+hjson/tests/test_namedtuple.py,sha256=iK7B95JH4f2L3_MB3rY9NagEVZ1X62JHpjlm1J4t5uM,4066
+hjson/tests/test_pass1.py,sha256=wdnBz55dY4ou8IIdZFypJ_72J6HCtLZw0YesoNOTopQ,1745
+hjson/tests/test_pass2.py,sha256=O389C8IeJ9ysqWKUftXOeHvBi5_47VSdBM_2bCee1SQ,385
+hjson/tests/test_pass3.py,sha256=wwemRholrfv4lwgC0ArnXiS_tfA-NnbRrZqo71YZXaA,481
+hjson/tests/test_recursion.py,sha256=APQAtnchO6KZdduYqvEJDrBOmAKqyORwAX4ldbzAW7A,1694
+hjson/tests/test_scanstring.py,sha256=U-5gUsaO7jEai6zfKMKADfBi-xFg8IHC1dBeElvTsn4,5953
+hjson/tests/test_separators.py,sha256=krudtyZbx0k7OrZZ-jGCZH6yrmsj1seRkUblQLRq4Rw,945
+hjson/tests/test_tool.py,sha256=PyDhrmMTpJSvBXvsWG8P-yrw1BT5kSp6OcSrMLvzmIw,2826
+hjson/tests/test_tuple.py,sha256=FkOyw4s7WZ1HUGxtHYiwaBwhW2thlDB3JFSpUZCbI_I,1976
+hjson/tests/test_unicode.py,sha256=5npz25rj4T3ZhXF_OsSmVveBUtTuz92DQ_cHDe-Jfrw,7099
+hjson/tool.py,sha256=PVlr-lSDWfrGdkh5exWQo_21HGgHLR4OpZ1S41Dqjgo,1897

parrot/lib/python3.10/site-packages/hjson-3.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hjson = hjson.tool:main

parrot/lib/python3.10/site-packages/narwhals-1.8.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

parrot/lib/python3.10/site-packages/narwhals-1.8.3.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.3
+Name: narwhals
+Version: 1.8.3
+Summary: Extremely lightweight compatibility layer between dataframe libraries
+Project-URL: Homepage, https://github.com/narwhals-dev/narwhals
+Project-URL: Bug Tracker, https://github.com/narwhals-dev/narwhals
+Author-email: Marco Gorelli <33491632+MarcoGorelli@users.noreply.github.com>
+License-File: LICENSE.md
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Provides-Extra: cudf
+Requires-Dist: cudf>=23.08.00; extra == 'cudf'
+Provides-Extra: dask
+Requires-Dist: dask[dataframe]>=2024.7; extra == 'dask'
+Provides-Extra: modin
+Requires-Dist: modin; extra == 'modin'
+Provides-Extra: pandas
+Requires-Dist: pandas>=0.25.3; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars>=0.20.3; extra == 'polars'
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow>=11.0.0; extra == 'pyarrow'
+Description-Content-Type: text/markdown
+
+# Narwhals
+
+<h1 align="center">
+	<img
+		width="400"
+		alt="narwhals_small"
+		src="https://github.com/narwhals-dev/narwhals/assets/33491632/26be901e-5383-49f2-9fbd-5c97b7696f27">
+</h1>
+
+[![PyPI version](https://badge.fury.io/py/narwhals.svg)](https://badge.fury.io/py/narwhals)
+[![Downloads](https://static.pepy.tech/badge/narwhals/month)](https://pepy.tech/project/narwhals)
+
+Extremely lightweight and extensible compatibility layer between dataframe libraries!
+
+- **Full API support**: cuDF, Modin, pandas, Polars, PyArrow
+- **Interchange-level support**: Ibis, Vaex, anything else which implements the DataFrame Interchange Protocol
+
+Seamlessly support all, without depending on any!
+
+- ✅ **Just use** a subset of **the Polars API**, no need to learn anything new
+- ✅ **Zero dependencies**, Narwhals only uses what
+  the user passes in so your library can stay lightweight
+- ✅ Separate **lazy** and eager APIs, use **expressions**
+- ✅ Support pandas' complicated type system and index, without
+  either getting in the way
+- ✅ **100% branch coverage**, tested against pandas and Polars nightly builds
+- ✅ **Negligible overhead**, see [overhead](https://narwhals-dev.github.io/narwhals/overhead/)
+- ✅ Let your IDE help you thanks to **full static typing**, see [typing](https://narwhals-dev.github.io/narwhals/api-reference/typing/)
+- ✅ **Perfect backwards compatibility policy**,
+  see [stable api](https://narwhals-dev.github.io/narwhals/backcompat/) for how to opt-in
+
+Get started!
+
+- [Read the documentation](https://narwhals-dev.github.io/narwhals/)
+- [Chat with us on Discord!](https://discord.gg/V3PqtB4VA4)
+- [Join our community call](https://calendar.google.com/calendar/embed?src=27ff6dc5f598c1d94c1f6e627a1aaae680e2fac88f848bda1f2c7946ae74d5ab%40group.calendar.google.com)
+- [Read the contributing guide](https://github.com/narwhals-dev/narwhals/blob/main/CONTRIBUTING.md)
+
+## Used by / integrates with
+
+Join the party!
+
+- [Altair](https://github.com/vega/altair/)
+- [Hamilton](https://github.com/DAGWorks-Inc/hamilton/tree/main/examples/narwhals)
+- [scikit-lego](https://github.com/koaning/scikit-lego)
+- [scikit-playtime](https://github.com/koaning/scikit-playtime)
+- [timebasedcv](https://github.com/FBruzzesi/timebasedcv)
+
+Feel free to add your project to the list if it's missing, and/or
+[chat with us on Discord](https://discord.gg/V3PqtB4VA4) if you'd like any support.
+
+## Installation
+
+- pip (recommended, as it's the most up-to-date)
+  ```
+  pip install narwhals
+  ```
+- conda-forge (also fine, but the latest version may take longer to appear)
+  ```
+  conda install -c conda-forge narwhals
+  ```
+
+## Usage
+
+There are three steps to writing dataframe-agnostic code using Narwhals:
+
+1. use `narwhals.from_native` to wrap a pandas/Polars/Modin/cuDF/PyArrow
+   DataFrame/LazyFrame in a Narwhals class
+2. use the [subset of the Polars API supported by Narwhals](https://narwhals-dev.github.io/narwhals/api-reference/)
+3. use `narwhals.to_native` to return an object to the user in its original
+   dataframe flavour. For example:
+
+   - if you started with pandas, you'll get pandas back
+   - if you started with Polars, you'll get Polars back
+   - if you started with Modin, you'll get Modin back (and compute will be distributed)
+   - if you started with cuDF, you'll get cuDF back (and compute will happen on GPU)
+   - if you started with PyArrow, you'll get PyArrow back
+
+<h1 align="left">
+	<img
+		width="600"
+		alt="narwhals_gif"
+		src="https://github.com/user-attachments/assets/88292d3c-6359-4155-973d-d0f8e3fbf5ac">
+
+</h1>
+
+## Example
+
+See the [tutorial](https://narwhals-dev.github.io/narwhals/basics/dataframe/) for several examples!
+
+## Scope
+
+- Do you maintain a dataframe-consuming library?
+- Do you have a specific Polars function in mind that you would like Narwhals to have in order to make your work easier?
+
+If you said yes to both, we'd love to hear from you!
+
+## Sponsors and institutional partners
+
+Narwhals is 100% independent, community-driven, and community-owned.
+We are extremely grateful to the following organisations for having
+provided some funding / development time:
+
+- [Quansight Labs](https://labs.quansight.org)
+- [Quansight Futures](https://www.qi.ventures)
+- [OpenTeams](https://www.openteams.com)
+- [POSSEE initiative](https://possee.org)
+- [BYU-Idaho](https://www.byui.edu)
+
+If you contribute to Narwhals on your organization's time, please let us know. We'd be happy to add your employer
+to this list!
+
+## Appears on
+
+Narwhals has been featured in several talks, podcasts, and blog posts:
+
+- [Talk Python to me Podcast](https://youtu.be/FSH7BZ0tuE0)
+  Ahoy, Narwhals are bridging the data science APIs
+
+- [Super Data Science: ML & AI Podcast](https://www.youtube.com/watch?v=TeG4U8R0U8U)  
+  Narwhals: For Pandas-to-Polars DataFrame Compatibility
+
+- [Sample Space Podcast | probabl](https://youtu.be/8hYdq4sWbbQ?si=WG0QP1CZ6gkFf18b)  
+  How Narwhals has many end users ... that never use it directly. - Marco Gorelli
+
+- [Pycon Lithuania](https://www.youtube.com/watch?v=-mdx7Cn6_6E)  
+  Marco Gorelli - DataFrame interoperatiblity - what's been achieved, and what comes next?
+
+- [Pycon Italy](https://www.youtube.com/watch?v=3IqUli9XsmQ)  
+  How you can write a dataframe-agnostic library - Marco Gorelli
+
+- [Polars Blog Post](https://pola.rs/posts/lightweight_plotting/)  
+  Polars has a new lightweight plotting backend
+
+- [Quansight Labs blog post (w/ Scikit-Lego)](https://labs.quansight.org/blog/scikit-lego-narwhals)  
+  How Narwhals and scikit-lego came together to achieve dataframe-agnosticism
+
+## Why "Narwhals"?
+
+[Coz they are so awesome](https://youtu.be/ykwqXuMPsoc?si=A-i8LdR38teYsos4).
+
+Thanks to [Olha Urdeichuk](https://www.fiverr.com/olhaurdeichuk) for the illustration!

parrot/lib/python3.10/site-packages/narwhals-1.8.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2022 Matthew Brennan Jones <matthew.brennan.jones@gmail.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.

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: py-cpuinfo
+Version: 9.0.0
+Summary: Get CPU info with pure Python
+Home-page: https://github.com/workhorsy/py-cpuinfo
+Author: Matthew Brennan Jones
+Author-email: matthew.brennan.jones@gmail.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+
+py-cpuinfo
+==========
+
+
+Py-cpuinfo gets CPU info with pure Python. Py-cpuinfo should work
+without any extra programs or libraries, beyond what your OS provides.
+It does not require any compilation(C/C++, assembly, et cetera) to use.
+It works with Python 3.
+
+Documentation can be viewed here: https://github.com/workhorsy/py-cpuinfo
+
+

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+../../../bin/cpuinfo,sha256=TFMOnqUj_85fFg6zgair4_gFfJAKY_omPPxgnPuNd4I,218
+cpuinfo/__init__.py,sha256=T6gndqGAggfJCu4_iOziTnomCN7KzaAK_OYTewE4FMA,44
+cpuinfo/__main__.py,sha256=nSxC6Hqhi-0lN7Z4WwtKdxQdf3cUJefb5hOahCzh4Yg,33
+cpuinfo/__pycache__/__init__.cpython-310.pyc,,
+cpuinfo/__pycache__/__main__.cpython-310.pyc,,
+cpuinfo/__pycache__/cpuinfo.cpython-310.pyc,,
+cpuinfo/cpuinfo.py,sha256=HHyDlDUNovE3QzJ3hviiM1ngyOC4iD7i6oGiz2iTmVk,84388
+py_cpuinfo-9.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+py_cpuinfo-9.0.0.dist-info/LICENSE,sha256=3br3Y5a_XHqkWXWiHq_i4i7st9paoNt8sOYVL6r-800,1127
+py_cpuinfo-9.0.0.dist-info/METADATA,sha256=rRFelvhFdoYcXnXXYDAbgdIxQ8_iVUa5lUHgEmU3ncE,794
+py_cpuinfo-9.0.0.dist-info/RECORD,,
+py_cpuinfo-9.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_cpuinfo-9.0.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+py_cpuinfo-9.0.0.dist-info/entry_points.txt,sha256=ZwrsclY_xUA0xJZK98bLxBdcowxnkK0ANYUT4FYcZJ8,42
+py_cpuinfo-9.0.0.dist-info/top_level.txt,sha256=XsjpunhkxD4hvznqQjrFNw0rtgizHEOGzewPZY3UEtU,8

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cpuinfo = cpuinfo:main
+

parrot/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cpuinfo

parrot/lib/python3.10/site-packages/pygments-2.18.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

parrot/lib/python3.10/site-packages/pygments-2.18.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.3
+Name: Pygments
+Version: 2.18.0
+Summary: Pygments is a syntax highlighting package written in Python.
+Project-URL: Homepage, https://pygments.org
+Project-URL: Documentation, https://pygments.org/docs
+Project-URL: Source, https://github.com/pygments/pygments
+Project-URL: Bug Tracker, https://github.com/pygments/pygments/issues
+Project-URL: Changelog, https://github.com/pygments/pygments/blob/master/CHANGES
+Author-email: Georg Brandl <georg@python.org>
+Maintainer: Matthäus G. Chajdas
+Maintainer-email: Georg Brandl <georg@python.org>, Jean Abou Samra <jean@abou-samra.fr>
+License: BSD-2-Clause
+License-File: AUTHORS
+License-File: LICENSE
+Keywords: syntax highlighting
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Text Processing :: Filters
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Provides-Extra: plugins
+Provides-Extra: windows-terminal
+Requires-Dist: colorama>=0.4.6; extra == 'windows-terminal'
+Description-Content-Type: text/x-rst
+
+Pygments
+~~~~~~~~
+
+Pygments is a syntax highlighting package written in Python.
+
+It is a generic syntax highlighter suitable for use in code hosting, forums,
+wikis or other applications that need to prettify source code.  Highlights
+are:
+
+* a wide range of over 500 languages and other text formats is supported
+* special attention is paid to details, increasing quality by a fair amount
+* support for new languages and formats are added easily
+* a number of output formats, presently HTML, LaTeX, RTF, SVG, all image
+  formats that PIL supports and ANSI sequences
+* it is usable as a command-line tool and as a library
+
+Copyright 2006-2024 by the Pygments team, see ``AUTHORS``.
+Licensed under the BSD, see ``LICENSE`` for details.

parrot/lib/python3.10/site-packages/pygments-2.18.0.dist-info/RECORD

@@ -0,0 +1,663 @@
+../../../bin/pygmentize,sha256=Qib3E_bw3Xp6moTVKSaq7P6HhybwxsAEARBiwvSCKiQ,227
+pygments-2.18.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pygments-2.18.0.dist-info/METADATA,sha256=WWViMDj3GoEuYl9sIbkmA7zv0m0H5sJTUXUSeY73bs8,2461
+pygments-2.18.0.dist-info/RECORD,,
+pygments-2.18.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygments-2.18.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+pygments-2.18.0.dist-info/entry_points.txt,sha256=uUXw-XhMKBEX4pWcCtpuTTnPhL3h7OEE2jWi51VQsa8,53
+pygments-2.18.0.dist-info/licenses/AUTHORS,sha256=REECiHykNMqFuqEk366APNvWe6irSUOqok67E3Evtzw,10500
+pygments-2.18.0.dist-info/licenses/LICENSE,sha256=qdZvHVJt8C4p3Oc0NtNOVuhjL0bCdbvf_HBWnogvnxc,1331
+pygments/__init__.py,sha256=d9try3r146jyYauE2BNZ8aJEYfsJlVdS9Bqv-fZZ5Pw,2959
+pygments/__main__.py,sha256=Wgnr5lhKPtecgPavxdwRzAAaZoe-fCuq6LAEBbBBXd0,348
+pygments/__pycache__/__init__.cpython-310.pyc,,
+pygments/__pycache__/__main__.cpython-310.pyc,,
+pygments/__pycache__/cmdline.cpython-310.pyc,,
+pygments/__pycache__/console.cpython-310.pyc,,
+pygments/__pycache__/filter.cpython-310.pyc,,
+pygments/__pycache__/formatter.cpython-310.pyc,,
+pygments/__pycache__/lexer.cpython-310.pyc,,
+pygments/__pycache__/modeline.cpython-310.pyc,,
+pygments/__pycache__/plugin.cpython-310.pyc,,
+pygments/__pycache__/regexopt.cpython-310.pyc,,
+pygments/__pycache__/scanner.cpython-310.pyc,,
+pygments/__pycache__/sphinxext.cpython-310.pyc,,
+pygments/__pycache__/style.cpython-310.pyc,,
+pygments/__pycache__/token.cpython-310.pyc,,
+pygments/__pycache__/unistring.cpython-310.pyc,,
+pygments/__pycache__/util.cpython-310.pyc,,
+pygments/cmdline.py,sha256=smQpJmIeqyPQ_xZ3Z9-O5FYDxTfngGg8icWV3hIcIIk,23536
+pygments/console.py,sha256=yhP9UsLAVmWKVQf2446JJewkA7AiXeeTf4Ieg3Oi2fU,1718
+pygments/filter.py,sha256=_ADNPCskD8_GmodHi6_LoVgPU3Zh336aBCT5cOeTMs0,1910
+pygments/filters/__init__.py,sha256=IuhzMxGWWMN9tYBZuO2VD602_Ai24ONZXc1cDKtFHPk,40344
+pygments/filters/__pycache__/__init__.cpython-310.pyc,,
+pygments/formatter.py,sha256=oPaCNqrEy_aGBGt-7zwzm9KpYs6v5tyfCd5nua233D4,4366
+pygments/formatters/__init__.py,sha256=C8E9WC8QpfxpCQSarFf_3KTaz21xEzw5N4ETSiv15zE,5349
+pygments/formatters/__pycache__/__init__.cpython-310.pyc,,
+pygments/formatters/__pycache__/_mapping.cpython-310.pyc,,
+pygments/formatters/__pycache__/bbcode.cpython-310.pyc,,
+pygments/formatters/__pycache__/groff.cpython-310.pyc,,
+pygments/formatters/__pycache__/html.cpython-310.pyc,,
+pygments/formatters/__pycache__/img.cpython-310.pyc,,
+pygments/formatters/__pycache__/irc.cpython-310.pyc,,
+pygments/formatters/__pycache__/latex.cpython-310.pyc,,
+pygments/formatters/__pycache__/other.cpython-310.pyc,,
+pygments/formatters/__pycache__/pangomarkup.cpython-310.pyc,,
+pygments/formatters/__pycache__/rtf.cpython-310.pyc,,
+pygments/formatters/__pycache__/svg.cpython-310.pyc,,
+pygments/formatters/__pycache__/terminal.cpython-310.pyc,,
+pygments/formatters/__pycache__/terminal256.cpython-310.pyc,,
+pygments/formatters/_mapping.py,sha256=1Cw37FuQlNacnxRKmtlPX4nyLoX9_ttko5ZwscNUZZ4,4176
+pygments/formatters/bbcode.py,sha256=EG993T9F65-VaRmq39A3vbmX-x8DyQh1hN4nAzqV6xg,3296
+pygments/formatters/groff.py,sha256=kEt7COeP_Cy5lqWUTO7w31bMyx56cpKG9ZPkN4RSMy4,5082
+pygments/formatters/html.py,sha256=bUbdrazRL2ONmkHWw1m2e6DHEIzwvJUogfiL_YhQT-U,35633
+pygments/formatters/img.py,sha256=V5fZUT6SKFnLJAxen7zVJw12EyXJyyLuOsiObTaGKCQ,23263
+pygments/formatters/irc.py,sha256=z1fWHg4G4sS8OMqY2N9b4k7k8bzJaKTkxo7Me8JQZGI,4945
+pygments/formatters/latex.py,sha256=Y2Nqn6a_QDxrlRju4_SYLQywJVsGBRtsHJ8Sup1hA4A,19258
+pygments/formatters/other.py,sha256=V2hrUtWYSS_klWzx1-h03aTxTkeBS4LEiVqy9ByPlKg,4986
+pygments/formatters/pangomarkup.py,sha256=JtIpELl-WIaZeoTJhfLbR7SkXmOhAp6I66lfRTPlxOA,2206
+pygments/formatters/rtf.py,sha256=Ffx6wgAqXr8iy4DhUkRiZlNiZ5QCe39fxPFvFScCOQ0,11921
+pygments/formatters/svg.py,sha256=JCIpG3y9p83APRD0vOSGU6rdsukv9rbZr81QpMIQlMw,7138
+pygments/formatters/terminal.py,sha256=B7X3InVYlDu142nk2wUkJcDtbKMLT1PA-Tfk49UE0j8,4626
+pygments/formatters/terminal256.py,sha256=B8t9Y8WJTgO2LWBGMXcRz2VfKySHLR-ZhGNuGQnDn98,11717
+pygments/lexer.py,sha256=9WU0ZHRI3mmVGymUCTgdVYNM3RRPUo-x_ijCGD1r8ho,35109
+pygments/lexers/__init__.py,sha256=svzhbvkX4ny7I2ALRRxd1yKzfRaUaGrY2Z0wrCNnd74,12067
+pygments/lexers/__pycache__/__init__.cpython-310.pyc,,
+pygments/lexers/__pycache__/_ada_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_asy_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_cl_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_cocoa_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_csound_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_css_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_julia_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_lasso_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_lilypond_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_lua_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_luau_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_mapping.cpython-310.pyc,,
+pygments/lexers/__pycache__/_mql_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_mysql_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_openedge_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_php_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_postgres_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_qlik_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_scheme_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_scilab_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_sourcemod_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_stan_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_stata_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_tsql_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_usd_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_vbscript_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/_vim_builtins.cpython-310.pyc,,
+pygments/lexers/__pycache__/actionscript.cpython-310.pyc,,
+pygments/lexers/__pycache__/ada.cpython-310.pyc,,
+pygments/lexers/__pycache__/agile.cpython-310.pyc,,
+pygments/lexers/__pycache__/algebra.cpython-310.pyc,,
+pygments/lexers/__pycache__/ambient.cpython-310.pyc,,
+pygments/lexers/__pycache__/amdgpu.cpython-310.pyc,,
+pygments/lexers/__pycache__/ampl.cpython-310.pyc,,
+pygments/lexers/__pycache__/apdlexer.cpython-310.pyc,,
+pygments/lexers/__pycache__/apl.cpython-310.pyc,,
+pygments/lexers/__pycache__/archetype.cpython-310.pyc,,
+pygments/lexers/__pycache__/arrow.cpython-310.pyc,,
+pygments/lexers/__pycache__/arturo.cpython-310.pyc,,
+pygments/lexers/__pycache__/asc.cpython-310.pyc,,
+pygments/lexers/__pycache__/asm.cpython-310.pyc,,
+pygments/lexers/__pycache__/asn1.cpython-310.pyc,,
+pygments/lexers/__pycache__/automation.cpython-310.pyc,,
+pygments/lexers/__pycache__/bare.cpython-310.pyc,,
+pygments/lexers/__pycache__/basic.cpython-310.pyc,,
+pygments/lexers/__pycache__/bdd.cpython-310.pyc,,
+pygments/lexers/__pycache__/berry.cpython-310.pyc,,
+pygments/lexers/__pycache__/bibtex.cpython-310.pyc,,
+pygments/lexers/__pycache__/blueprint.cpython-310.pyc,,
+pygments/lexers/__pycache__/boa.cpython-310.pyc,,
+pygments/lexers/__pycache__/bqn.cpython-310.pyc,,
+pygments/lexers/__pycache__/business.cpython-310.pyc,,
+pygments/lexers/__pycache__/c_cpp.cpython-310.pyc,,
+pygments/lexers/__pycache__/c_like.cpython-310.pyc,,
+pygments/lexers/__pycache__/capnproto.cpython-310.pyc,,
+pygments/lexers/__pycache__/carbon.cpython-310.pyc,,
+pygments/lexers/__pycache__/cddl.cpython-310.pyc,,
+pygments/lexers/__pycache__/chapel.cpython-310.pyc,,
+pygments/lexers/__pycache__/clean.cpython-310.pyc,,
+pygments/lexers/__pycache__/comal.cpython-310.pyc,,
+pygments/lexers/__pycache__/compiled.cpython-310.pyc,,
+pygments/lexers/__pycache__/configs.cpython-310.pyc,,
+pygments/lexers/__pycache__/console.cpython-310.pyc,,
+pygments/lexers/__pycache__/cplint.cpython-310.pyc,,
+pygments/lexers/__pycache__/crystal.cpython-310.pyc,,
+pygments/lexers/__pycache__/csound.cpython-310.pyc,,
+pygments/lexers/__pycache__/css.cpython-310.pyc,,
+pygments/lexers/__pycache__/d.cpython-310.pyc,,
+pygments/lexers/__pycache__/dalvik.cpython-310.pyc,,
+pygments/lexers/__pycache__/data.cpython-310.pyc,,
+pygments/lexers/__pycache__/dax.cpython-310.pyc,,
+pygments/lexers/__pycache__/devicetree.cpython-310.pyc,,
+pygments/lexers/__pycache__/diff.cpython-310.pyc,,
+pygments/lexers/__pycache__/dns.cpython-310.pyc,,
+pygments/lexers/__pycache__/dotnet.cpython-310.pyc,,
+pygments/lexers/__pycache__/dsls.cpython-310.pyc,,
+pygments/lexers/__pycache__/dylan.cpython-310.pyc,,
+pygments/lexers/__pycache__/ecl.cpython-310.pyc,,
+pygments/lexers/__pycache__/eiffel.cpython-310.pyc,,
+pygments/lexers/__pycache__/elm.cpython-310.pyc,,
+pygments/lexers/__pycache__/elpi.cpython-310.pyc,,
+pygments/lexers/__pycache__/email.cpython-310.pyc,,
+pygments/lexers/__pycache__/erlang.cpython-310.pyc,,
+pygments/lexers/__pycache__/esoteric.cpython-310.pyc,,
+pygments/lexers/__pycache__/ezhil.cpython-310.pyc,,
+pygments/lexers/__pycache__/factor.cpython-310.pyc,,
+pygments/lexers/__pycache__/fantom.cpython-310.pyc,,
+pygments/lexers/__pycache__/felix.cpython-310.pyc,,
+pygments/lexers/__pycache__/fift.cpython-310.pyc,,
+pygments/lexers/__pycache__/floscript.cpython-310.pyc,,
+pygments/lexers/__pycache__/forth.cpython-310.pyc,,
+pygments/lexers/__pycache__/fortran.cpython-310.pyc,,
+pygments/lexers/__pycache__/foxpro.cpython-310.pyc,,
+pygments/lexers/__pycache__/freefem.cpython-310.pyc,,
+pygments/lexers/__pycache__/func.cpython-310.pyc,,
+pygments/lexers/__pycache__/functional.cpython-310.pyc,,
+pygments/lexers/__pycache__/futhark.cpython-310.pyc,,
+pygments/lexers/__pycache__/gcodelexer.cpython-310.pyc,,
+pygments/lexers/__pycache__/gdscript.cpython-310.pyc,,
+pygments/lexers/__pycache__/go.cpython-310.pyc,,
+pygments/lexers/__pycache__/grammar_notation.cpython-310.pyc,,
+pygments/lexers/__pycache__/graph.cpython-310.pyc,,
+pygments/lexers/__pycache__/graphics.cpython-310.pyc,,
+pygments/lexers/__pycache__/graphql.cpython-310.pyc,,
+pygments/lexers/__pycache__/graphviz.cpython-310.pyc,,
+pygments/lexers/__pycache__/gsql.cpython-310.pyc,,
+pygments/lexers/__pycache__/haskell.cpython-310.pyc,,
+pygments/lexers/__pycache__/haxe.cpython-310.pyc,,
+pygments/lexers/__pycache__/hdl.cpython-310.pyc,,
+pygments/lexers/__pycache__/hexdump.cpython-310.pyc,,
+pygments/lexers/__pycache__/html.cpython-310.pyc,,
+pygments/lexers/__pycache__/idl.cpython-310.pyc,,
+pygments/lexers/__pycache__/igor.cpython-310.pyc,,
+pygments/lexers/__pycache__/inferno.cpython-310.pyc,,
+pygments/lexers/__pycache__/installers.cpython-310.pyc,,
+pygments/lexers/__pycache__/int_fiction.cpython-310.pyc,,
+pygments/lexers/__pycache__/iolang.cpython-310.pyc,,
+pygments/lexers/__pycache__/j.cpython-310.pyc,,
+pygments/lexers/__pycache__/javascript.cpython-310.pyc,,
+pygments/lexers/__pycache__/jmespath.cpython-310.pyc,,
+pygments/lexers/__pycache__/jslt.cpython-310.pyc,,
+pygments/lexers/__pycache__/jsonnet.cpython-310.pyc,,
+pygments/lexers/__pycache__/jsx.cpython-310.pyc,,
+pygments/lexers/__pycache__/julia.cpython-310.pyc,,
+pygments/lexers/__pycache__/jvm.cpython-310.pyc,,
+pygments/lexers/__pycache__/kuin.cpython-310.pyc,,
+pygments/lexers/__pycache__/kusto.cpython-310.pyc,,
+pygments/lexers/__pycache__/ldap.cpython-310.pyc,,
+pygments/lexers/__pycache__/lean.cpython-310.pyc,,
+pygments/lexers/__pycache__/lilypond.cpython-310.pyc,,
+pygments/lexers/__pycache__/lisp.cpython-310.pyc,,
+pygments/lexers/__pycache__/macaulay2.cpython-310.pyc,,
+pygments/lexers/__pycache__/make.cpython-310.pyc,,
+pygments/lexers/__pycache__/markup.cpython-310.pyc,,
+pygments/lexers/__pycache__/math.cpython-310.pyc,,
+pygments/lexers/__pycache__/matlab.cpython-310.pyc,,
+pygments/lexers/__pycache__/maxima.cpython-310.pyc,,
+pygments/lexers/__pycache__/meson.cpython-310.pyc,,
+pygments/lexers/__pycache__/mime.cpython-310.pyc,,
+pygments/lexers/__pycache__/minecraft.cpython-310.pyc,,
+pygments/lexers/__pycache__/mips.cpython-310.pyc,,
+pygments/lexers/__pycache__/ml.cpython-310.pyc,,
+pygments/lexers/__pycache__/modeling.cpython-310.pyc,,
+pygments/lexers/__pycache__/modula2.cpython-310.pyc,,
+pygments/lexers/__pycache__/mojo.cpython-310.pyc,,
+pygments/lexers/__pycache__/monte.cpython-310.pyc,,
+pygments/lexers/__pycache__/mosel.cpython-310.pyc,,
+pygments/lexers/__pycache__/ncl.cpython-310.pyc,,
+pygments/lexers/__pycache__/nimrod.cpython-310.pyc,,
+pygments/lexers/__pycache__/nit.cpython-310.pyc,,
+pygments/lexers/__pycache__/nix.cpython-310.pyc,,
+pygments/lexers/__pycache__/oberon.cpython-310.pyc,,
+pygments/lexers/__pycache__/objective.cpython-310.pyc,,
+pygments/lexers/__pycache__/ooc.cpython-310.pyc,,
+pygments/lexers/__pycache__/openscad.cpython-310.pyc,,
+pygments/lexers/__pycache__/other.cpython-310.pyc,,
+pygments/lexers/__pycache__/parasail.cpython-310.pyc,,
+pygments/lexers/__pycache__/parsers.cpython-310.pyc,,
+pygments/lexers/__pycache__/pascal.cpython-310.pyc,,
+pygments/lexers/__pycache__/pawn.cpython-310.pyc,,
+pygments/lexers/__pycache__/perl.cpython-310.pyc,,
+pygments/lexers/__pycache__/phix.cpython-310.pyc,,
+pygments/lexers/__pycache__/php.cpython-310.pyc,,
+pygments/lexers/__pycache__/pointless.cpython-310.pyc,,
+pygments/lexers/__pycache__/pony.cpython-310.pyc,,
+pygments/lexers/__pycache__/praat.cpython-310.pyc,,
+pygments/lexers/__pycache__/procfile.cpython-310.pyc,,
+pygments/lexers/__pycache__/prolog.cpython-310.pyc,,
+pygments/lexers/__pycache__/promql.cpython-310.pyc,,
+pygments/lexers/__pycache__/prql.cpython-310.pyc,,
+pygments/lexers/__pycache__/ptx.cpython-310.pyc,,
+pygments/lexers/__pycache__/python.cpython-310.pyc,,
+pygments/lexers/__pycache__/q.cpython-310.pyc,,
+pygments/lexers/__pycache__/qlik.cpython-310.pyc,,
+pygments/lexers/__pycache__/qvt.cpython-310.pyc,,
+pygments/lexers/__pycache__/r.cpython-310.pyc,,
+pygments/lexers/__pycache__/rdf.cpython-310.pyc,,
+pygments/lexers/__pycache__/rebol.cpython-310.pyc,,
+pygments/lexers/__pycache__/resource.cpython-310.pyc,,
+pygments/lexers/__pycache__/ride.cpython-310.pyc,,
+pygments/lexers/__pycache__/rita.cpython-310.pyc,,
+pygments/lexers/__pycache__/rnc.cpython-310.pyc,,
+pygments/lexers/__pycache__/roboconf.cpython-310.pyc,,
+pygments/lexers/__pycache__/robotframework.cpython-310.pyc,,
+pygments/lexers/__pycache__/ruby.cpython-310.pyc,,
+pygments/lexers/__pycache__/rust.cpython-310.pyc,,
+pygments/lexers/__pycache__/sas.cpython-310.pyc,,
+pygments/lexers/__pycache__/savi.cpython-310.pyc,,
+pygments/lexers/__pycache__/scdoc.cpython-310.pyc,,
+pygments/lexers/__pycache__/scripting.cpython-310.pyc,,
+pygments/lexers/__pycache__/sgf.cpython-310.pyc,,
+pygments/lexers/__pycache__/shell.cpython-310.pyc,,
+pygments/lexers/__pycache__/sieve.cpython-310.pyc,,
+pygments/lexers/__pycache__/slash.cpython-310.pyc,,
+pygments/lexers/__pycache__/smalltalk.cpython-310.pyc,,
+pygments/lexers/__pycache__/smithy.cpython-310.pyc,,
+pygments/lexers/__pycache__/smv.cpython-310.pyc,,
+pygments/lexers/__pycache__/snobol.cpython-310.pyc,,
+pygments/lexers/__pycache__/solidity.cpython-310.pyc,,
+pygments/lexers/__pycache__/soong.cpython-310.pyc,,
+pygments/lexers/__pycache__/sophia.cpython-310.pyc,,
+pygments/lexers/__pycache__/special.cpython-310.pyc,,
+pygments/lexers/__pycache__/spice.cpython-310.pyc,,
+pygments/lexers/__pycache__/sql.cpython-310.pyc,,
+pygments/lexers/__pycache__/srcinfo.cpython-310.pyc,,
+pygments/lexers/__pycache__/stata.cpython-310.pyc,,
+pygments/lexers/__pycache__/supercollider.cpython-310.pyc,,
+pygments/lexers/__pycache__/tact.cpython-310.pyc,,
+pygments/lexers/__pycache__/tal.cpython-310.pyc,,
+pygments/lexers/__pycache__/tcl.cpython-310.pyc,,
+pygments/lexers/__pycache__/teal.cpython-310.pyc,,
+pygments/lexers/__pycache__/templates.cpython-310.pyc,,
+pygments/lexers/__pycache__/teraterm.cpython-310.pyc,,
+pygments/lexers/__pycache__/testing.cpython-310.pyc,,
+pygments/lexers/__pycache__/text.cpython-310.pyc,,
+pygments/lexers/__pycache__/textedit.cpython-310.pyc,,
+pygments/lexers/__pycache__/textfmts.cpython-310.pyc,,
+pygments/lexers/__pycache__/theorem.cpython-310.pyc,,
+pygments/lexers/__pycache__/thingsdb.cpython-310.pyc,,
+pygments/lexers/__pycache__/tlb.cpython-310.pyc,,
+pygments/lexers/__pycache__/tls.cpython-310.pyc,,
+pygments/lexers/__pycache__/tnt.cpython-310.pyc,,
+pygments/lexers/__pycache__/trafficscript.cpython-310.pyc,,
+pygments/lexers/__pycache__/typoscript.cpython-310.pyc,,
+pygments/lexers/__pycache__/typst.cpython-310.pyc,,
+pygments/lexers/__pycache__/ul4.cpython-310.pyc,,
+pygments/lexers/__pycache__/unicon.cpython-310.pyc,,
+pygments/lexers/__pycache__/urbi.cpython-310.pyc,,
+pygments/lexers/__pycache__/usd.cpython-310.pyc,,
+pygments/lexers/__pycache__/varnish.cpython-310.pyc,,
+pygments/lexers/__pycache__/verification.cpython-310.pyc,,
+pygments/lexers/__pycache__/verifpal.cpython-310.pyc,,
+pygments/lexers/__pycache__/vip.cpython-310.pyc,,
+pygments/lexers/__pycache__/vyper.cpython-310.pyc,,
+pygments/lexers/__pycache__/web.cpython-310.pyc,,
+pygments/lexers/__pycache__/webassembly.cpython-310.pyc,,
+pygments/lexers/__pycache__/webidl.cpython-310.pyc,,
+pygments/lexers/__pycache__/webmisc.cpython-310.pyc,,
+pygments/lexers/__pycache__/wgsl.cpython-310.pyc,,
+pygments/lexers/__pycache__/whiley.cpython-310.pyc,,
+pygments/lexers/__pycache__/wowtoc.cpython-310.pyc,,
+pygments/lexers/__pycache__/wren.cpython-310.pyc,,
+pygments/lexers/__pycache__/x10.cpython-310.pyc,,
+pygments/lexers/__pycache__/xorg.cpython-310.pyc,,
+pygments/lexers/__pycache__/yang.cpython-310.pyc,,
+pygments/lexers/__pycache__/yara.cpython-310.pyc,,
+pygments/lexers/__pycache__/zig.cpython-310.pyc,,
+pygments/lexers/_ada_builtins.py,sha256=hnh_MphEm4skkHsAGGlVSp9-IG1IvA-Kkkplc54-WPI,1543
+pygments/lexers/_asy_builtins.py,sha256=nwBhZjbOkPUFReF22JgCde_AR6oaUBr1TEwIJDgxtec,27287
+pygments/lexers/_cl_builtins.py,sha256=gwESyMaPG0eSdwgr9uNUuEMmjX43Z5Nav5z9pDGnhMA,13994
+pygments/lexers/_cocoa_builtins.py,sha256=wa8Z6xRSVHiETfxU2WOuY4O9VN9ogH8PoVw4IpnTIYA,105173
+pygments/lexers/_csound_builtins.py,sha256=vr4PKbi_2T5iSdWLfqARILPB0Z-Wc_CPGjNaHvQhySQ,18414
+pygments/lexers/_css_builtins.py,sha256=5O6M8QQQ5518sqLorWlafT_eoN6mIbkT6OogR7gAq6M,12446
+pygments/lexers/_julia_builtins.py,sha256=f_mAv1J9t-4kA85bUlf5iazlZrjBj8X39LMrg6bOBAc,11883
+pygments/lexers/_lasso_builtins.py,sha256=a7MYoYE1yAgwyl7pHFpSZazz6VQLRI5pLCV8nn1xcvk,134510
+pygments/lexers/_lilypond_builtins.py,sha256=HOmm1nxJwnJIMKJ0IcCdZeAWF1a2-g2_0_lmGbxqNmg,108094
+pygments/lexers/_lua_builtins.py,sha256=8EUwcejkeZ4CpFxSoo2DON1UwFnJhbYRpF7Q22xiQ-8,8108
+pygments/lexers/_luau_builtins.py,sha256=eX-OzjU9gT4gvoVwCttALJMZxk2repLtc7mqHY54xWs,955
+pygments/lexers/_mapping.py,sha256=nPWeLyQslZd_A4ehzIefyWxmvcaTtqSCW6RMb47m9Xs,69089
+pygments/lexers/_mql_builtins.py,sha256=_1MtbSYIUf4B1Yl9hGVm-N4jdj7lcxmx3yFoiWzO3vM,24713
+pygments/lexers/_mysql_builtins.py,sha256=A5OlN4LrN-Ig1rfsUoLAaS80B_vYTG4Fj9bwiq_qGuc,25838
+pygments/lexers/_openedge_builtins.py,sha256=fTAp0gK3PEBDg47Rrdygxql73_C-AdHg8EGJ_Ld8p0U,49398
+pygments/lexers/_php_builtins.py,sha256=MikQttLCEbHulmTMT1LzJpRhDzUvuzRl0Yh-iKYyn1M,107922
+pygments/lexers/_postgres_builtins.py,sha256=-e9B90henKpkQDqEQGkS0sIeKGlg-l5VdDPWuSw5TtY,13343
+pygments/lexers/_qlik_builtins.py,sha256=ccaWjko7s6PNJnthww0eksfBH4kkrYy1qkWSwA7wk6o,12595
+pygments/lexers/_scheme_builtins.py,sha256=uQVSWBP5oCjD6YoV37xY3Ep4ao8fIVd8oSBlqqBn0og,32564
+pygments/lexers/_scilab_builtins.py,sha256=6kTzoifN-Dmbg7nlJJD1_ar3lEq6Uq5sdWCjV0A1R9A,52411
+pygments/lexers/_sourcemod_builtins.py,sha256=GxGZ9MWhiyrNktPoc57VdwxAA6sguWyFM_v09GcW3nc,26777
+pygments/lexers/_stan_builtins.py,sha256=aICL2mRN0xyWWknCUGVSS6s0HoK_rk91OmiYXSn2dMw,13445
+pygments/lexers/_stata_builtins.py,sha256=1JS2rARgtMan7763FA_zZ7UFT7t8YsGNJo47kLt4e2E,27227
+pygments/lexers/_tsql_builtins.py,sha256=ZVzbdvOcC-kbs1lXcaTAT3-XwgMJuPbYQtAc6jxb9ZY,15460
+pygments/lexers/_usd_builtins.py,sha256=dZRmB_M4Z-aVZFPG5FU-5Su6bPZOvJmCcNxYIF80MXo,1658
+pygments/lexers/_vbscript_builtins.py,sha256=ZVJrzBsxkQKPHVkrBNmWSHaWJcKYaPa9oiCTckzrqKA,4225
+pygments/lexers/_vim_builtins.py,sha256=vN66emQdRrvXF--5n2XOP1_8OI5VO96rxXlKABI4eAA,57066
+pygments/lexers/actionscript.py,sha256=o-fGli0AVanHyaN-nYkedrYgdE49umtHCduObXtfK_s,11727
+pygments/lexers/ada.py,sha256=O0T9BR80xzRn7MAYlf3BDJsQxDIS6x14x6sjLkK4gmo,5353
+pygments/lexers/agile.py,sha256=sWWEMQnlDt99eVuZyjd5uvnuebxCJ4ad2-UXAqti1iQ,896
+pygments/lexers/algebra.py,sha256=CdDxjCBPoETdvmErRu5TG67jy0KQhCmOVsO6nYH2Ym4,9912
+pygments/lexers/ambient.py,sha256=pVJWRy2554RUhQjxwF4JFMPkWbgt-bmqXPvsMu_rWb0,2605
+pygments/lexers/amdgpu.py,sha256=_LuGGZoY9bqDYf4OaPldxEvbhKvP_xqOy3T4gAKHbdg,1723
+pygments/lexers/ampl.py,sha256=q84rYyzGP1qmriMeZVt5Cl8ohugv1tp1hNdfWBYmU50,4176
+pygments/lexers/apdlexer.py,sha256=o0mYCKG9to1Foq7VAQmYQzn7WS7Qt1YH6zSApqv32wM,30800
+pygments/lexers/apl.py,sha256=YChhnBp5WIzKP2FZGDIBpqztQDS58hPz0Wi7mXcQgpA,3404
+pygments/lexers/archetype.py,sha256=8UDdDTxLyIyNCfGnH_dU90St96Jsnl9t2XshWW7dXm4,11538
+pygments/lexers/arrow.py,sha256=MfJlUb169MPfelyrH0jXCWkHfSLTljBCrknYQyAbpUA,3564
+pygments/lexers/arturo.py,sha256=PsV5SMa5h2RHgj161xJJDJX-0ubZ2Eyzt8bxzYeOC8g,11414
+pygments/lexers/asc.py,sha256=ZiLshADiwSba6srjtwibovBVX4hqXqquYK7_AAf4Ofw,1693
+pygments/lexers/asm.py,sha256=9QSICK9VKJLfjxMkEtkkrEGzbB2q6SZd9egDMlGWW1s,41934
+pygments/lexers/asn1.py,sha256=S7psbkDQTLFZd1jDK8KaWVkyi-wHiz7AFf2b1WN7YrQ,4262
+pygments/lexers/automation.py,sha256=Lv4-0vpmwFOX6dbsQHfKG9m7yOyrI6F7km16Z3O9ZTw,19831
+pygments/lexers/bare.py,sha256=s934nvvtAeG8avdi-Q04ZVQebjpo8xbZdhMH_FNnev0,3020
+pygments/lexers/basic.py,sha256=oHx7F-C6gW7AULTU_zfA8zowbmmxcdoyniYZIiaVd6o,27989
+pygments/lexers/bdd.py,sha256=I0tooXMevZw1eND_hrdAWtJ3n3nXgUDKDM5IoYJHRUg,1641
+pygments/lexers/berry.py,sha256=sLmGllDvhPB51Pe_M9BFx10QkqDGejcVZQxCVwEUIeA,3209
+pygments/lexers/bibtex.py,sha256=13JE6k9k1TUYTKit0zND246zLQ0xyL52lvMkrYopP14,4811
+pygments/lexers/blueprint.py,sha256=FZ2WkBuqlOBu0GH0rqjnNSHG_qdAu3jGt97Oen19feA,6188
+pygments/lexers/boa.py,sha256=T_VWCvNM-wt9IjPW4FV7u8NFngpx14dr9ZN7RdOLLVQ,3921
+pygments/lexers/bqn.py,sha256=ze1whgy0AsdgoEc1yHgk_4f2LihqOHjCVPUojA4BehE,3337
+pygments/lexers/business.py,sha256=j1h6DphSHRFwPB5shVQfrPsajprPItPKjHxqzQfdZTo,28345
+pygments/lexers/c_cpp.py,sha256=8e-rRebFzZgYSd52bXFShriP8jFVlCf0L2F0vI-9Rmg,18059
+pygments/lexers/c_like.py,sha256=JCHZRIboeGb0VE-bknxnoxd8oWQhr8T0qhS2i8vTlMI,32021
+pygments/lexers/capnproto.py,sha256=MJmnE8MYtWPUEqXh2_zBgG9FgQAD-10so6ORwpqHZRo,2174
+pygments/lexers/carbon.py,sha256=oYL5HLBgNOJIkLti5kjFFdwGIbtidKflCKk2tdHKgos,3211
+pygments/lexers/cddl.py,sha256=qaeINyt59SyAbxAMZHY0zcDGgxTEFPElG6DP3aa5nZA,5076
+pygments/lexers/chapel.py,sha256=XBFfoaOiLbfUvaNvnp_iQs_qLRpg41LUmAugtg-XGug,5156
+pygments/lexers/clean.py,sha256=vUMnhYzD3uvSc7Wdyzo7PZllAGt0dzXqhthY82qhL9c,6418
+pygments/lexers/comal.py,sha256=G_d_FHFU-wJFihoMPmZMLGF_Bl__HO0i1gC9InQ9rbE,3179
+pygments/lexers/compiled.py,sha256=nufWnAfB85AiZPELv0yzijrROD2wz9SEc54e9n_dmGk,1426
+pygments/lexers/configs.py,sha256=vNh6sytziBn-1qkqDwy_OFYTKxUH4kFsJ65Hc8Yx2Oc,50534
+pygments/lexers/console.py,sha256=39fVAcHxYtO7cy2_epBq30ShxDJxhgc09jd5J7dOAzE,4180
+pygments/lexers/cplint.py,sha256=0lqEPgDIFQuO7Q189JjG5whWlAw_YcTlWG9-aA6eli8,1389
+pygments/lexers/crystal.py,sha256=5UlYigeTeFRrfhHQiSN0DxqkWo2ibnhtcCErB5bTJdg,15754
+pygments/lexers/csound.py,sha256=ZX2bs4NykljvsrI5QXgQZXGH2IyP6ztFfT1v6gq3UnQ,16998
+pygments/lexers/css.py,sha256=571dDjM2lWepEn3ybYec0I5b3h54azXF7xJO2ZNyRLA,25366
+pygments/lexers/d.py,sha256=-mKlYHZMYsUV2BhW8C43AFnh97zeKJgyej7XSQbOA_I,9920
+pygments/lexers/dalvik.py,sha256=PIEJoUcYD7lij6eCg9wZgMFhUyazyQ8oFxHrpzmQFMk,4606
+pygments/lexers/data.py,sha256=l1fmUUlwiBccMAKX06phQ1tKr27mDpzwhnytwqxTbM0,27026
+pygments/lexers/dax.py,sha256=blHXcUy-QL9X25rLQDDW5DUceThB3sSa_4mOtCT1bkE,8098
+pygments/lexers/devicetree.py,sha256=K1jqVm8B-2K8rRzMElMNYWNUaUKbCIt62dVRQVjINI0,4019
+pygments/lexers/diff.py,sha256=_dlEodnJh3Y61GgP3AvRNpbC0LD-0nuOSd7PBDaOK-I,5382
+pygments/lexers/dns.py,sha256=do6plOeMEqasazJTfGpjYYTWLqvGKsTVNAd3SldgG_8,3891
+pygments/lexers/dotnet.py,sha256=apkKKord2c6opVFhiaK-vRrQxsJRRnFfhijPLKiMYS4,37958
+pygments/lexers/dsls.py,sha256=ea7bLN68qYqwx1yeRJvfn1YJP343rawhdO9NuDMRjnM,36746
+pygments/lexers/dylan.py,sha256=kcx1IB9pqjQyy4PXpu4YeiS64I8XSkE5dJ3ulWDWzMg,10391
+pygments/lexers/ecl.py,sha256=qmFlYH19sYDOli4aTjajecw_zRlvjmzq_VUeGfcEUk8,6371
+pygments/lexers/eiffel.py,sha256=8fpkGHe6drmZvcKOJkS0jz87H61JsQc3_999IM4Mg1c,2690
+pygments/lexers/elm.py,sha256=Dvh8YtUEbcnCC15pCmMGIuZFGenLsg_rS4X97GOyJiA,3152
+pygments/lexers/elpi.py,sha256=1JMrWjlWYdle82RJSZ0rTtTOCt9kLktyVJOumeK2dMc,6535
+pygments/lexers/email.py,sha256=vR1gKbuso2-oiJG5QXYUROYjaOGw8tYD9CmdbY68lAg,4804
+pygments/lexers/erlang.py,sha256=3xVUmnbvgbQN4QM5WGvIoQMFS9jJptBCRM3MP4KxsZo,19147
+pygments/lexers/esoteric.py,sha256=N9HJNvtxh5ktL_I8t_8vFJ6Ms-atOkplnE39GGe8wNg,10500
+pygments/lexers/ezhil.py,sha256=BfutGlZYc9b9uW5Qy4BIsNKWowdikL9mWijA-D_xK1M,3272
+pygments/lexers/factor.py,sha256=yxEbxsEFcReEaajn5S7bvaacuG2me1RRY5Fb2hYDW2M,19530
+pygments/lexers/fantom.py,sha256=meOft3jMJ98kNGetDPVvzu9nvVFC08udETA18j51TQ4,10231
+pygments/lexers/felix.py,sha256=o3E1v8qe9vyQjS9YK_LVPKwraosmfqqypRpOx7J-ikI,9655
+pygments/lexers/fift.py,sha256=ZTjrY--aKiHlg24KFpKUAq-wn8ULL_8G_E7N3TPMnKg,1644
+pygments/lexers/floscript.py,sha256=LYiIZfZ2HT05T3xR00J9_q5S6nxkEw-2v5GkcuS9kfI,2667
+pygments/lexers/forth.py,sha256=xyeyN7nMFszsaKYDG2oxLuhfjrZcBVKdRIKL6htxvSQ,7193
+pygments/lexers/fortran.py,sha256=llxa3itGDZfNWcmsQO55DjmWgvfvgohnEdt1T4m3AHo,10382
+pygments/lexers/foxpro.py,sha256=KW39vSlXkigjRqx6E7s7L895l4auXk9T9iyWB3XbjY4,26295
+pygments/lexers/freefem.py,sha256=gO8XOaVcwydnhWP8t2Cgl2YeQ4C75dbGDsQs3ko3SQo,26913
+pygments/lexers/func.py,sha256=2yYrp5etRM94BT0nkxxlcC2xAJ4PBOP8mV4i6flNmJo,3700
+pygments/lexers/functional.py,sha256=RJSf7XrVmsGQRYbbHKhWlJtfI5PZ6stlH8Va8WMdpLo,693
+pygments/lexers/futhark.py,sha256=QPbnZ_MvzMTQmYMTJbdJIvW8w7hQySJCViOTDH0Pv6I,3743
+pygments/lexers/gcodelexer.py,sha256=QE3tz5_Wu0c1GsjiVU-nbLi4ZcvGvRKjTUdT3VFbErA,874
+pygments/lexers/gdscript.py,sha256=eBdkj-lmw2TVTf7cvJYsFHVzEZ0C7kyZyVHHuelJ18A,7566
+pygments/lexers/go.py,sha256=dZY74RhlgVS7sZwEiqYm21AOOZ-NqrDXUHBz5aTkdDw,3783
+pygments/lexers/grammar_notation.py,sha256=vg1BvwySit-7LB8Y_5AQkgkj0AzIGAM0mHtaq_fbuYs,8043
+pygments/lexers/graph.py,sha256=kUfbhtuS9ysgfhUdFBnT86w_JK35I-ROzOZ3IQV7sTU,4108
+pygments/lexers/graphics.py,sha256=PXcPVmfAOROL1ocKa6ft6J3HfKgZQ9HvZ2k7AcSPl70,39145
+pygments/lexers/graphql.py,sha256=um1AZrLHx9qpZ6NFVBX_kRAFbM7TQV9l13ep7dCpKcY,5601
+pygments/lexers/graphviz.py,sha256=P-Xy34waH0BYD-Ccp1XmE9832I5MzO-_mwHsRrA5n0U,1934
+pygments/lexers/gsql.py,sha256=8y3ymaD6uFx-IrFJRy0D6i9wruaUETd_ceAsugtaxIw,3990
+pygments/lexers/haskell.py,sha256=e7WpOTNyaIj7Sr8B-JjGeGbSlACLVEa6vOM-XfWMrK0,33239
+pygments/lexers/haxe.py,sha256=hHGZkJt4JWpLHMTb0s6a01yQNxfnXgTPvnP-eyNp6YE,30974
+pygments/lexers/hdl.py,sha256=Vr-kHDFjxhQSE1TW4zttZ2zZHDCuXzpNcQL3tCjjjOI,22738
+pygments/lexers/hexdump.py,sha256=5F4mjn6fgyA1CaWFoYk4Ww-pHS02a_7zpoRr70WPm8A,3653
+pygments/lexers/html.py,sha256=dPeQnP4Qf8z6TZjL642FHTMMHRwCUccGVAAD90ORzXk,20574
+pygments/lexers/idl.py,sha256=UnYt9-IWBk37Kr0YvCCtU2D5TXWSIqPSmeglq7Wd-V4,15449
+pygments/lexers/igor.py,sha256=KvamBRiJOU67TDqHGB_PixR19IR1c9Fq0oLScXFPlmw,31626
+pygments/lexers/inferno.py,sha256=kSrMfu_3AofmBZ2uCH_YFD-0a95XRjmOKk7L_hB6CIA,3135
+pygments/lexers/installers.py,sha256=IVyOtXNeV3AVFv-18TjGbMF2xPgiI-kVejAo_EszuNA,13297
+pygments/lexers/int_fiction.py,sha256=LSf2BROdA4Mz_rgpsKLICJebljE3nQsh_K0hJvfVlaQ,56544
+pygments/lexers/iolang.py,sha256=XL_JsHAZRziGN8Sk08NZmSo5irAWU27yVy7czpU9GtQ,1905
+pygments/lexers/j.py,sha256=_fomKXuUh8FANTUl-HxE_x9WYRnKJGpAiQUMeVJUolo,4853
+pygments/lexers/javascript.py,sha256=m6VcUOwTUcpdZoJNaAIXE_zHq8NZBkQVqYZMRPXI1VE,63101
+pygments/lexers/jmespath.py,sha256=GBHuBxeDVdeUN03KuvFK4UIY3e79gYT0FkiDMWKgygw,2082
+pygments/lexers/jslt.py,sha256=p_0Qba5bPcyxERl2xsmFKet7_P0R5R0ist_3GFrN2us,3700
+pygments/lexers/jsonnet.py,sha256=bqXv1lRpxoIx8X-_Y1PIwOl-jgnEPtilCUL4wT2-2xE,5636
+pygments/lexers/jsx.py,sha256=qlRxi85Fh0kPvD5Viff9_Xm-gjfmEEKm3AsVDWTgM5o,2233
+pygments/lexers/julia.py,sha256=DLaYCAF4AN8nsgRzJY-MWlHEZtDuNZ4FznIFijJatGM,11679
+pygments/lexers/jvm.py,sha256=OFw18wPlecJDJjt16N3gMQVy_xmnxjcDCXlu4_NXTYQ,72666
+pygments/lexers/kuin.py,sha256=axJ3_tqZKu40OgkUP27qsyDEkM_TeZGQcKFXlYOrtMI,11405
+pygments/lexers/kusto.py,sha256=Q-UC6DQB4vuxtVsQcMZEp56CxXpIlJXeuP-WDEV-Eww,3477
+pygments/lexers/ldap.py,sha256=_ua5KpHLgDiTCKFVZ4OJkoBUh84FXGqeDX29UELMYzg,6551
+pygments/lexers/lean.py,sha256=bk6LaVc_PsSEhspNLzRMKkG6KyFWup7nhS7Kx1XXQ34,8570
+pygments/lexers/lilypond.py,sha256=gE6Z5xs7uocSCfaDOghkowKGblZX8zIE_v9eLZ651UQ,9752
+pygments/lexers/lisp.py,sha256=79Upl-OrKzZ-8443lyPRJHagOSwDGkxywKqJwXF66FA,157668
+pygments/lexers/macaulay2.py,sha256=iRTPn040k600ZQiY4IpPL-Byt027wBBhFMWn9QjgROc,32844
+pygments/lexers/make.py,sha256=5-2Mq3muMg9Yq5yfmXNI7UH-ApYh9VePrIvKsJTpNHg,7831
+pygments/lexers/markup.py,sha256=tgFazIqyrufzmAgd3FL-4-WMbwbc8ve5P7tJGvPWnOs,65088
+pygments/lexers/math.py,sha256=lI6LVR-OqL5XB46Nu41YE00QA1WKssPp1TFzH-NoV50,695
+pygments/lexers/matlab.py,sha256=gXzVaLWkjqmwqNJgxpyNbfqy8X2yDs9QyJaGQcXBu94,132962
+pygments/lexers/maxima.py,sha256=Qfe8sTugA5UhGuRzEKjspbH-w6YVlREdAAmGyKp5HZc,2715
+pygments/lexers/meson.py,sha256=FmmaxUNRV55nxQm6oQ2sXhhZZyNSms68V7Uxj7F9TuQ,4336
+pygments/lexers/mime.py,sha256=nwyBkz2_gJ-jUmxWpcNvpGYftazfk4V9adzcPashGeg,7582
+pygments/lexers/minecraft.py,sha256=GKPEYWI6HHvpOdEh4GTphfAM4mx8dOA6VFOsA0-1aAk,13696
+pygments/lexers/mips.py,sha256=YtvYhgqSdYtfy69FK5I7EiOPC2VSKdqq5_ZgPHD1wbE,4656
+pygments/lexers/ml.py,sha256=hZvMkwBzbgWYX4ndtUI_m9xAjjGmxyqPbwJe7FcAeoY,35390
+pygments/lexers/modeling.py,sha256=EebFhvTaBw279EkIcRDvIsGIo33A8TTgtvn__Ypun7A,13683
+pygments/lexers/modula2.py,sha256=2rHAQBCVnLu0mdaq8ERDPuHwF0wNh2r5SKl_vUJMea4,53072
+pygments/lexers/mojo.py,sha256=z9CDFFnBfI9G9gHRsYOtcCtKWbXKdLgRdvoKRVAoWTA,24181
+pygments/lexers/monte.py,sha256=DTy0svJRg7P7j7EwDPN5aG7l98Bm7STANyJSwOytv5c,6289
+pygments/lexers/mosel.py,sha256=cErB67hM5hw1qZYPKuHmOfrJu8H8uDk8B378hnCyI6M,9297
+pygments/lexers/ncl.py,sha256=zyV63ZeQnoV__OY6284jW8GENuzsXgY-_d6HxDz7m0w,63999
+pygments/lexers/nimrod.py,sha256=lBDewJqj_VNdsKQJ-8qQ--_ZFNbQZETraP8u92b62xU,6413
+pygments/lexers/nit.py,sha256=M91yluzYKftVIr2HsWdianN4gPirwBLybF287xiVb-o,2725
+pygments/lexers/nix.py,sha256=oUlbwP0ktviAB6lMtrzVwrzsgw09BPN0OS5NM6IMK40,4421
+pygments/lexers/oberon.py,sha256=QmaSlH1Magq2Kn6DlzZtowxTRWVTivoWPLsVj5ywHY8,4210
+pygments/lexers/objective.py,sha256=W3ikK5MZiP2nF8gpGO0wSA5LM3TGE6Z1GHkLFQXq0aI,23240
+pygments/lexers/ooc.py,sha256=xpKo2xGSael8ymrTyXhfyL7630zBx_Gatb4fEZ9qn14,2981
+pygments/lexers/openscad.py,sha256=u-Ow27qJeR3l6N-8gSzJ4ZsvviBvCylCbMnc3pCgb_s,3700
+pygments/lexers/other.py,sha256=U4tWdbxxxa-__MU48rejsw6n-OyZHf3ikk0O7dG4jxo,1763
+pygments/lexers/parasail.py,sha256=9KkwIh9KuvGjI_cgFuzlTOTZEgyPcLnz1ikKOM48x48,2719
+pygments/lexers/parsers.py,sha256=mZAfSp6U1KwcfnjzBUojmO_G1dlYMG8KEnaWqr4d5Ko,26596
+pygments/lexers/pascal.py,sha256=k1vWSa2xiclhbHYK9bcEj6pUgBR-RT2oLTagK9zn5YA,30989
+pygments/lexers/pawn.py,sha256=eYfJfp9ibWIJL0R5CGzg94vZI0nxlRI5bkbzzWuc3vM,8253
+pygments/lexers/perl.py,sha256=uVou8njqVI4tzGM2iX6P3OPud4FipZK-Zi2uFAhcOBA,39192
+pygments/lexers/phix.py,sha256=q-P5CcxMRvOGHuFAY5wAPUFWUY9IsGNj8gC7K5g28lE,23249
+pygments/lexers/php.py,sha256=UkF4jrSzj7HsTwrkPF42xTm-kOF3jT-yvc7CzicfwMI,13061
+pygments/lexers/pointless.py,sha256=pdrIHwcAcCJGfwHxFGHoJ_KkQXwPH2OKJbnlqIEugtU,1974
+pygments/lexers/pony.py,sha256=FIrwgNLoN1shYp_JQk9TzzWy_GzWp1Fikc8niAUA8Zc,3279
+pygments/lexers/praat.py,sha256=KZP6jV2BaJXeNEtGzCvGW7EO8tbNomTGuW3vqQ0BIoA,12676
+pygments/lexers/procfile.py,sha256=hdl66BmCMFYjVkD2Do41OsKL9qoo5cOFty6u1il1f7s,1155
+pygments/lexers/prolog.py,sha256=7ThE10pBk1juL1S87a_IBucCtEirJ4SdMHWv60hLw4s,12866
+pygments/lexers/promql.py,sha256=T6Vth5trlmxvEUZFlwaNmQIMqc6gks16Xjv6VLlNiD8,4738
+pygments/lexers/prql.py,sha256=yGEiiPGYoRS_BpWarVwu7iQV3ZY301w928fk_kIVXjo,8747
+pygments/lexers/ptx.py,sha256=bvZwgSRXvlP5FhYEeIJR08tqrdJzG4iz_l-GfaYGmXU,4501
+pygments/lexers/python.py,sha256=KEHRWLVhykUPwl10uBIev1RnQ5h5qGgcjVP-mtsY1rQ,53639
+pygments/lexers/q.py,sha256=j5sI-L_KvvtNVnghW7fDVTkPUpGeS8RMVetadtZkSZQ,6936
+pygments/lexers/qlik.py,sha256=BcEHm92Js-FoekcsuGx-Wp8B379PonGqV-CLEKqd7hA,3693
+pygments/lexers/qvt.py,sha256=kAu8NJpjGktB9Z4wJAMoQbGc8LafMV1b6z-R9XEyqA4,6103
+pygments/lexers/r.py,sha256=5AFY4SAj7RmscCdU4WYuI-XTnPBgryGkPKxvTkw3UDk,6342
+pygments/lexers/rdf.py,sha256=GigtsRZmYwMjFzebvH1LV6ops_gi5OqxDCfZ_xBZ1Lc,16042
+pygments/lexers/rebol.py,sha256=gacBQsL85pcTpjJS1UUKDrlmFanRnnPJYphjQDSmYiw,18259
+pygments/lexers/resource.py,sha256=Mve3WMK62BrefqaJzwnHai23DIPvg-qdu0vQumJPhzA,2927
+pygments/lexers/ride.py,sha256=qUAqA8gIMecQj3FOemfeYOtQ_iGC_mVkawdE6oUNopc,5035
+pygments/lexers/rita.py,sha256=2fP6PGLEPZVhUOWaU00sC36r2QWnZVi07QQ2BhLY1bE,1127
+pygments/lexers/rnc.py,sha256=E-4DyG21UILNE5UPpUSl43UmbaDA9JPEnrjFlPembuA,1972
+pygments/lexers/roboconf.py,sha256=0J7CIBT5CE0A18sjOJV4M3J2tAvGs_WC2M2GTYSmshE,2074
+pygments/lexers/robotframework.py,sha256=Nh5SSW_bchdqtioQo6bt3q4ULuL4dsoYau5_Pu-ah-I,18448
+pygments/lexers/ruby.py,sha256=vTykyjbAPIG-mRBnNKNgNGeAXwsv7MB8xWOkzrhpsWg,22753
+pygments/lexers/rust.py,sha256=B_H41x0dgnatX9zRLNAVOdPiEgFpENIXFYW7Jfsv8GQ,8260
+pygments/lexers/sas.py,sha256=FDX4GAE1Pcr5vmwCSSUx5Ym7qOPzQzxXiDnqqQzwnQ8,9456
+pygments/lexers/savi.py,sha256=eUiiyyRMQTXJacqlreYj8RgjZGPSTlpiJ9Ctll9cjjA,4878
+pygments/lexers/scdoc.py,sha256=9YOBIrmKLIC30ceVtfG4Qy5HHNWfzqb9Fw1-L3poZZQ,2524
+pygments/lexers/scripting.py,sha256=3mDK3eT62VIq-cmAo3js6wDxOYemfYtGQXccbGbMh-I,81062
+pygments/lexers/sgf.py,sha256=wfWiRnyh8Z9fl6oN0SGrDDcdrXSozvmTEDqHK0AOIiw,1985
+pygments/lexers/shell.py,sha256=kpL7It9fUab8bCQSKAPJiJuzWsgA6Tv5zo6TnmRdkiU,36234
+pygments/lexers/sieve.py,sha256=ymmZ8ZubRoVtBcgOr0UW_Dg5siMpJqgpZXC6LmE7RJo,2514
+pygments/lexers/slash.py,sha256=hc5BWEaTGxyGhIwaRaQAayXbr53Q6H3ZwHTC5o5R-WY,8484
+pygments/lexers/smalltalk.py,sha256=GxnNoY4eYE2-reCp4OL0d4DHBtHsZJTymRZY31Fq1lM,7204
+pygments/lexers/smithy.py,sha256=PjLWFlb-qYnEfkTOkLkpSBxkfG6gXCXsU-Pf42FKE0g,2659
+pygments/lexers/smv.py,sha256=w-WL-lSg0NKJKTEzZH94QeHQbMQlbxoId-vUP1nAbJk,2805
+pygments/lexers/snobol.py,sha256=vEBdaH4C9F6ctEKmMuWMmK_WKyCC40yi6q4HbXUZavo,2778
+pygments/lexers/solidity.py,sha256=Bc3mELp5mXvZNgr3vRzAqjKRtC6SPNhfmsaD6RdJGyc,3163
+pygments/lexers/soong.py,sha256=YpDy1HvoABJU26xq2-y0xs8BKIZyO3635VrYKOizhQ0,2339
+pygments/lexers/sophia.py,sha256=SxKzCczr5WU19adkc-NbnPCcY5ecN5Fx97zRsFhk7Rk,3376
+pygments/lexers/special.py,sha256=6-K1Ik28Dle15Ol_b1UANMcRIX7EcTo_Fbf3Wr-zp-k,3554
+pygments/lexers/spice.py,sha256=QKbDr0PSRObjF3knMghglx8zFVp2Hjrq8zSAn6XVWlc,2790
+pygments/lexers/sql.py,sha256=ESU6S2vX1jucKfOhe1tW8hKVluFTZYTvClB1AnGI9Kk,42594
+pygments/lexers/srcinfo.py,sha256=Lv2ptfstgzOtzY2MGqCUcDadyntJrCQMTP-rOie2iuU,1746
+pygments/lexers/stata.py,sha256=sxOLP7jb6UReJCjxUHJYAbgAJV7M_LNOGywLwkPWXTE,6415
+pygments/lexers/supercollider.py,sha256=dYszvpnKfaLGdmIEnruntz9VTccLmUYwzbbLvZfOPC4,3697
+pygments/lexers/tact.py,sha256=5KVnr9VxJeh_RKmbgOwR09X-5n7Th8Yb-Zk_0XTQovo,10809
+pygments/lexers/tal.py,sha256=VF3YLB4xvQB52W4GW9ZVNkDqkyPXASlHALhOJupw2SI,2904
+pygments/lexers/tcl.py,sha256=mepJbvCnYmZR1-dKK9Cfkt9m08bwTg7fOs96k2csfGg,5512
+pygments/lexers/teal.py,sha256=gCEC8QyKyq3aQk6E8E98fwD3vJrVZs58XsGjJ6GTL_4,3522
+pygments/lexers/templates.py,sha256=ASVTvkCvKfD7Ay5eETo7vs2Izc4ISP-UBUhpds_O1Yo,75719
+pygments/lexers/teraterm.py,sha256=3gwNILGwryBxytCTzS6qVGcZBFRfOX7svC11w4EpgSY,9718
+pygments/lexers/testing.py,sha256=5pQIJ7ZNeT02-GM0krZOXo8Pc3s6IbYbS46w0KjHaKE,10810
+pygments/lexers/text.py,sha256=EF6zAFvul6KpvQMPJrRw1FIr5ALAP8aScZ9VRqutid0,1048
+pygments/lexers/textedit.py,sha256=Kf8ALySo9XQ_UY6X9quOLA782ZwHvBHL17expjthZQI,7760
+pygments/lexers/textfmts.py,sha256=0_1KYSlbmLTZmFpX5iXktRKJ8OyVO9QmAFDg__rXGUk,15524
+pygments/lexers/theorem.py,sha256=z09aU_G5UI9DpsWf6jm-XPWcuUSKwJrAsLYqLgQuS8c,17855
+pygments/lexers/thingsdb.py,sha256=cLu1oiOV0R1mR9oZWX2wD03G0s7MWhkvguZ70FPgkaM,6017
+pygments/lexers/tlb.py,sha256=meibbT7CuzX9aFdel3o9uJDM9s4BsWHrHSd8SxyUl3Y,1450
+pygments/lexers/tls.py,sha256=o6vcxSNMeQmq9jIRY5Muyt2ETwLomqWK983LnENX9vU,1540
+pygments/lexers/tnt.py,sha256=okaq1-TxloDyopXy9pu6Ts5TbkfOqqynNzTbObH8JE0,10456
+pygments/lexers/trafficscript.py,sha256=U7l9JD39m5YHtmO50vR-5pilR1QBMxO2RdqWe-wkUyY,1506
+pygments/lexers/typoscript.py,sha256=dohTsxka3AAjgRfRYSyqO4WLxa_kcscDMf8SHxPWUKY,8332
+pygments/lexers/typst.py,sha256=lou5GsSvL-FuBVyDMT8Tg8jOXl4V3RW2exEPqUbmfXE,4337
+pygments/lexers/ul4.py,sha256=DyVoCHqF9AxIDJzFuBLcBgDbkXQzqhEmtcAkc4umnXA,10499
+pygments/lexers/unicon.py,sha256=TH8FGcxImq4Ioq20cKHfTN3abwD-1YaImuf_MC1s7rk,18625
+pygments/lexers/urbi.py,sha256=KreG90URYP6Xq-Cq5yLqkntpSmksjyJLrMo2ume7dM8,6082
+pygments/lexers/usd.py,sha256=p_wZfBLvMILyTTohmkxxJPWTce89zb_TMHFZcZY5mw0,3304
+pygments/lexers/varnish.py,sha256=YfIyQPkChcQ4VzcbDvGX7FLuemL2m9vB4w8hiyRKVfE,7473
+pygments/lexers/verification.py,sha256=iZR-iWX_SWCAYZ3YqIWjhcTmQdmtiEomay18Gz8HdVw,3934
+pygments/lexers/verifpal.py,sha256=dKEqh3m32VjEF_Bn0Ies8-Q0RkTfaKfJd06a9snQqmE,2661
+pygments/lexers/vip.py,sha256=nHw6Yq4msTQaJqnDEEmnH6O4KfxCwxPEnMPfHJQr8uE,5711
+pygments/lexers/vyper.py,sha256=I6Sr2i3ObogDbhElepwGzvnIH__htWF6cys3PqbimmM,5590
+pygments/lexers/web.py,sha256=a5Da6fOZsK8ft4lj86ADqZnBFgV3jNw7oZCd_nepWXI,913
+pygments/lexers/webassembly.py,sha256=sXB1c9mVobzv5F8rEmRi4re3UgTD_iGxHR3rf0zQieY,5698
+pygments/lexers/webidl.py,sha256=9eutoEoxDJk6MEbcQIpM79EkQalU2-DDKbZQQKDYsrg,10516
+pygments/lexers/webmisc.py,sha256=3CxiToHU2w3cHqyOizoWlP0rZAsrASowZQWZIu5XC-Q,40564
+pygments/lexers/wgsl.py,sha256=PrBbAe9TxRiJXQhm7kiwLsiKFm3y0X4I66whtWGOIAs,11880
+pygments/lexers/whiley.py,sha256=iH-TV5itY3LNcr1072PapDpMX2ys2RIKthe98F3BXhg,4017
+pygments/lexers/wowtoc.py,sha256=K1-o9Ui3vr7yMUWNoipFZmQUzTrvzRkvm6Z0_S4FDk8,4076
+pygments/lexers/wren.py,sha256=TOQXYQk-Vl0XLJ4_TZcsSaBiJMqE8KKi5Xu8A-nrrmM,3229
+pygments/lexers/x10.py,sha256=lHNR_3TM82-nl5FynZByOZ-YlX_jFz3relStlHriDIk,1943
+pygments/lexers/xorg.py,sha256=UriOYGMw2YiogLg7a1pVHQ_byUE1rkYybIw252-yL-I,925
+pygments/lexers/yang.py,sha256=kzRAGm1AELRrc3NF6xN4Axc-M2DTzf90zqd0vyLIMWI,4499
+pygments/lexers/yara.py,sha256=IhbIy7H8A__Y023fNwLgXzSW5H0SI0uHyzt2cXY75AI,2427
+pygments/lexers/zig.py,sha256=nnm8oDDjYCLGB_JhWHobZ9hP1U_JIXJdyyetxyAJ2WQ,3976
+pygments/modeline.py,sha256=gtRYZBS-CKOCDXHhGZqApboHBaZwGH8gznN3O6nuxj4,1005
+pygments/plugin.py,sha256=ioeJ3QeoJ-UQhZpY9JL7vbxsTVuwwM7BCu-Jb8nN0AU,1891
+pygments/regexopt.py,sha256=Hky4EB13rIXEHQUNkwmCrYqtIlnXDehNR3MztafZ43w,3072
+pygments/scanner.py,sha256=NDy3ofK_fHRFK4hIDvxpamG871aewqcsIb6sgTi7Fhk,3092
+pygments/sphinxext.py,sha256=gQAWnR6_1SM6OwUypWg1DlXrmmF9o3ZzbxsaXDsiRVg,7898
+pygments/style.py,sha256=dCFnKszVtsMeSW20uHC4pU3yuYgVPuJggm64-2Ylmo4,6408
+pygments/styles/__init__.py,sha256=v0aGLoaoKnp4_MGp4w-cmUvMoHYHMemiz_e_IPMLpbg,2006
+pygments/styles/__pycache__/__init__.cpython-310.pyc,,
+pygments/styles/__pycache__/_mapping.cpython-310.pyc,,
+pygments/styles/__pycache__/abap.cpython-310.pyc,,
+pygments/styles/__pycache__/algol.cpython-310.pyc,,
+pygments/styles/__pycache__/algol_nu.cpython-310.pyc,,
+pygments/styles/__pycache__/arduino.cpython-310.pyc,,
+pygments/styles/__pycache__/autumn.cpython-310.pyc,,
+pygments/styles/__pycache__/borland.cpython-310.pyc,,
+pygments/styles/__pycache__/bw.cpython-310.pyc,,
+pygments/styles/__pycache__/coffee.cpython-310.pyc,,
+pygments/styles/__pycache__/colorful.cpython-310.pyc,,
+pygments/styles/__pycache__/default.cpython-310.pyc,,
+pygments/styles/__pycache__/dracula.cpython-310.pyc,,
+pygments/styles/__pycache__/emacs.cpython-310.pyc,,
+pygments/styles/__pycache__/friendly.cpython-310.pyc,,
+pygments/styles/__pycache__/friendly_grayscale.cpython-310.pyc,,
+pygments/styles/__pycache__/fruity.cpython-310.pyc,,
+pygments/styles/__pycache__/gh_dark.cpython-310.pyc,,
+pygments/styles/__pycache__/gruvbox.cpython-310.pyc,,
+pygments/styles/__pycache__/igor.cpython-310.pyc,,
+pygments/styles/__pycache__/inkpot.cpython-310.pyc,,
+pygments/styles/__pycache__/lightbulb.cpython-310.pyc,,
+pygments/styles/__pycache__/lilypond.cpython-310.pyc,,
+pygments/styles/__pycache__/lovelace.cpython-310.pyc,,
+pygments/styles/__pycache__/manni.cpython-310.pyc,,
+pygments/styles/__pycache__/material.cpython-310.pyc,,
+pygments/styles/__pycache__/monokai.cpython-310.pyc,,
+pygments/styles/__pycache__/murphy.cpython-310.pyc,,
+pygments/styles/__pycache__/native.cpython-310.pyc,,
+pygments/styles/__pycache__/nord.cpython-310.pyc,,
+pygments/styles/__pycache__/onedark.cpython-310.pyc,,
+pygments/styles/__pycache__/paraiso_dark.cpython-310.pyc,,
+pygments/styles/__pycache__/paraiso_light.cpython-310.pyc,,
+pygments/styles/__pycache__/pastie.cpython-310.pyc,,
+pygments/styles/__pycache__/perldoc.cpython-310.pyc,,
+pygments/styles/__pycache__/rainbow_dash.cpython-310.pyc,,
+pygments/styles/__pycache__/rrt.cpython-310.pyc,,
+pygments/styles/__pycache__/sas.cpython-310.pyc,,
+pygments/styles/__pycache__/solarized.cpython-310.pyc,,
+pygments/styles/__pycache__/staroffice.cpython-310.pyc,,
+pygments/styles/__pycache__/stata_dark.cpython-310.pyc,,
+pygments/styles/__pycache__/stata_light.cpython-310.pyc,,
+pygments/styles/__pycache__/tango.cpython-310.pyc,,
+pygments/styles/__pycache__/trac.cpython-310.pyc,,
+pygments/styles/__pycache__/vim.cpython-310.pyc,,
+pygments/styles/__pycache__/vs.cpython-310.pyc,,
+pygments/styles/__pycache__/xcode.cpython-310.pyc,,
+pygments/styles/__pycache__/zenburn.cpython-310.pyc,,
+pygments/styles/_mapping.py,sha256=6lovFUE29tz6EsV3XYY4hgozJ7q1JL7cfO3UOlgnS8w,3312
+pygments/styles/abap.py,sha256=9rx_hWD_GptC9nhoXVVc3p8ysYJ9wQfcReqgzyic2OM,749
+pygments/styles/algol.py,sha256=zeOLl6K37RauOH7chM5o_MC7UyTo81kk6sEOn5Joy8o,2262
+pygments/styles/algol_nu.py,sha256=XGmfWujpWLfNJ4AL7BJX0Xyr3wp3vUEV7x7eYj4Z5y4,2283
+pygments/styles/arduino.py,sha256=7IEZ8-xN_h8FjvuJFZiuVmZKC69gD57zgWussXjPsco,4557
+pygments/styles/autumn.py,sha256=76KNB7kJfZIOqcH0nZ0y6kh8xWWQc_-agkIJFWbCdf4,2195
+pygments/styles/borland.py,sha256=Gv5bXGIKuMGr0Oi4rbOrmEhZzdwHNLA20iQcuHg9yGQ,1611
+pygments/styles/bw.py,sha256=zJUiRQGS9OIE7H82M--9A8_jiqWTUPmjf0ZfWz0eSNY,1406
+pygments/styles/coffee.py,sha256=vdWBg6Oaj6T_TvfDSX1Ex6C8jOMggi1ZukUdMErPioE,2308
+pygments/styles/colorful.py,sha256=x6Oka6AQiGm-PtzuF5AdHUUZk61ZZXhvjOjHdsuFsTE,2832
+pygments/styles/default.py,sha256=YVxaKrvLvV9PD3I_7J6OE9gIYZE0O4fRWVr2qY9YWMg,2588
+pygments/styles/dracula.py,sha256=qcgo21Tvi-_KyjXvHHWQus19kNYJbtOvDZbYDcMXBno,2182
+pygments/styles/emacs.py,sha256=FknUJ19Pkh3iRLtVwUwxDOGwvVcJ8ZWPegGbCbTLlq4,2535
+pygments/styles/friendly.py,sha256=wbmM_eI7io4ZiU7s04dbLu8MyBHi0nwkSCvA4PjhA10,2604
+pygments/styles/friendly_grayscale.py,sha256=4VH0U_dWcANmzD5YvTfNGBAHt1NMa64Gxqvh2cMB5fY,2828
+pygments/styles/fruity.py,sha256=lZKB5CspS2-7XiCS0HUR1Rw_p8bf7H5auyYXdH0RviA,1324
+pygments/styles/gh_dark.py,sha256=q4ydCJLNNemg3FrShh3OeX3LLkI_ix6ZwAzsZ_U7bIA,3590
+pygments/styles/gruvbox.py,sha256=kNlwHRuiNt6nFiV73HjEM9R7CpaYVzCyL19PWoKdVAA,3387
+pygments/styles/igor.py,sha256=pxC51nXipMCi3K2lYzuTJI3VkwPTqF7xSu5co_PiU0s,737
+pygments/styles/inkpot.py,sha256=jRs2u3nQsLhUOX3Fkl4eaNurasOtlEy3wKCMPWcPpFE,2404
+pygments/styles/lightbulb.py,sha256=RJcQHPcC3SfqOtyWOzOXGysd5iyirTkkR6cqxch9LRQ,3172
+pygments/styles/lilypond.py,sha256=faTOHQ9NCV-yWV3AxhnQ6wMvakoxQ8oBZw5BTDQOYGo,2066
+pygments/styles/lovelace.py,sha256=y-5nl4TavhUCYrTHU_ysTNQDh40dUeqiGrAQuPmF1xc,3178
+pygments/styles/manni.py,sha256=-zRQEJnjkXJpGmMMlJSOMNGho6VAsDimCvW79aqntG4,2443
+pygments/styles/material.py,sha256=28SYTw9qOuQS42Qsy8lDUNBvJzbliNH8Crq0e5N2sIc,4201
+pygments/styles/monokai.py,sha256=TvyWTqvy6oZxKNARKT7mgt2LgmNKLy2DL8Tphj6kjWk,5184
+pygments/styles/murphy.py,sha256=txf8iMJaPpynJRtnZJILTAagWhZ7Vdxn9DGcn8TE_q4,2805
+pygments/styles/native.py,sha256=0Ke0kSPZ3ARlI6ncLQzLiYGM660OpcuhNJfzHwJyVLU,2043
+pygments/styles/nord.py,sha256=Ee-EgGAEhW8Yi2CNxx2URZm2AGFADHurN9BwFIDBcd4,5391
+pygments/styles/onedark.py,sha256=SpfxQcze3C4s8R1DIxBn_YmuZC65X8UoShN8Dzuyuxs,1719
+pygments/styles/paraiso_dark.py,sha256=4IBihUb0MsjbT1CXpmIYx2kxwDZRXh4wPRgxXXzbuvM,5662
+pygments/styles/paraiso_light.py,sha256=6_LiKp3-cjlNW3q82poUZJktJQBhoUVROB0UgbgCPRs,5668
+pygments/styles/pastie.py,sha256=Y1FWBgt6FDcZxpbiaAgj2x7_4gx-d_fSSwdhSnfcFRU,2525
+pygments/styles/perldoc.py,sha256=n280hEgwbxNgHWnY5tvpwvBWoeKokUP3xYeSMnUDu0s,2230
+pygments/styles/rainbow_dash.py,sha256=FHP8Es63TK_81EkyhlDTMZbZ-IqTKG3FkACbwMdJKVc,2390
+pygments/styles/rrt.py,sha256=-PdgNtub-w6B04dL_BZxoztjMl42JdtekA_OLO-QXDw,964
+pygments/styles/sas.py,sha256=wFRC1zzCjIaUoxp7F2F4PsQlrLgi0Lhl73EBhBa6MZU,1440
+pygments/styles/solarized.py,sha256=sxXpKTLLJqbOZSaikQr9xK2YC39aMd7s1cVZk0WncnY,4247
+pygments/styles/staroffice.py,sha256=Q8lR_zkR-YTqdyNNETypBdIjCGx4lQhUitdC56DKntY,831
+pygments/styles/stata_dark.py,sha256=6HrS2rre1SjqCnhvFU_fZ0k657owP1tQO5UdY7xQk-k,1257
+pygments/styles/stata_light.py,sha256=AleMjdPmr3OqBLdBrLyYRs_Qnnr2s27zWuh88CPtYY8,1289
+pygments/styles/tango.py,sha256=N68BibRMXHmNTIt2-gH2krdqErgKmKaWiv3l5mO_yG4,7137
+pygments/styles/trac.py,sha256=FVuEbNlIthXD2ajLaWBewGTvyx9tQtmleg-7Cigwnj4,1981
+pygments/styles/vim.py,sha256=RxqkvCriR3QwCxZsSjTwFUzNBmFEcWKWbn5H9w7hwDE,2019
+pygments/styles/vs.py,sha256=cG9_3FVzYiirGa8uesnwH4q1L6ZRb9nlwy_W1SAZ19w,1130
+pygments/styles/xcode.py,sha256=4A2br07F5Q7X8dUkqu14oHLGT5zsuOiv-e0V0UYCCu4,1504
+pygments/styles/zenburn.py,sha256=EyWeyFH9wRLSHc2S4v-rgFIro_b8H9Ia-gaRE2PJgCs,2203
+pygments/token.py,sha256=qZwT7LSPy5YBY3JgDjut642CCy7JdQzAfmqD9NmT5j0,6226
+pygments/unistring.py,sha256=p5c1i-HhoIhWemy9CUsaN9o39oomYHNxXll0Xfw6tEA,63208
+pygments/util.py,sha256=2tj2nS1X9_OpcuSjf8dOET2bDVZhs8cEKd_uT6-Fgg8,10031

parrot/lib/python3.10/site-packages/pygments-2.18.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.24.2
+Root-Is-Purelib: true
+Tag: py3-none-any