def add_extension(self, name: str, extension: "BaseExtension") -> None:
    """
    Adds an extension to the client. This is called automatically when an extension is loaded.

    Parameters
    ----------
    name : str
        The name of the extension.
    extension : BaseExtension
        The extension to add.
    """
    self._ext_tasks.append((extension.setup, name))
    setattr(self, name, extension)

async def close(self) -> None:
    """
    Closes the client session. Recommended to use this when the client is no longer needed.
    Not needed if the client is used in a context manager.
    """
    self.logger.warning("Closing session!")
    await self._http.close()

async def from_url(self, url: str) -> BaseType:
    """
    Constructs a request from urls present in the data.

    Parameters
    ----------
    url : str
        The URL to construct the request from.

    Returns
    -------
    BaseType
        The data from the URL.

    Raises
    ------
    ValueError
        If the url is invalid.
    ResourceNotFound
        If the data is not found.
    """
    if params := ExtensionEnum.validate_url(url):
        return await self.getch_data(params.extension, params.category, params.value)
    raise ValueError(f"Invalid URL: {url}")

@alru_cache(maxsize=128, typed=True)
async def get_audio_async(self, url: str) -> bytes:
    """
    Gets an audio from the url asynchronously.

    Parameters
    ----------
    url : str
        The URL to get the audio from.

    Returns
    -------
    bytes
        The audio data.
    """
    return await self._http.load_audio(url)

@alru_cache(maxsize=128, typed=True)
async def get_image_async(self, url: str) -> bytes:
    """
    Gets an image from the url asynchronously.

    Parameters
    ----------
    url : str
        The URL to get the image from.

    Returns
    -------
    bytes
        The image data.
    """
    return await self._http.load_image(url)

async def getch_data(
    self, ext: t.Union[ExtensionEnum, ExtensionsL, str], category: str, id_: t.Union[int, str]
) -> BaseType:
    """
    A getch method that looks up the cache for the data first then gets it from the API if it is not found.

    Parameters
    ----------
    ext : Union[ExtensionEnum, ExtensionsL, str]
        The extension to get the data from.
    category : str
        The category to get the data from.
    id_ : Union[int, str]
        The ID of the data to get.

    Returns
    -------
    BaseType
        The data.

    Raises
    ------
    ValueError
        If the extension or category is invalid.
    ResourceNotFound
        If the data is not found.

    Examples
    --------
    >>> import pokelance
    >>> import asyncio
    >>> from pokelance.constants import ExtensionEnum
    >>> from pokelance.models import Pokemon
    >>> client = pokelance.PokeLance()
    >>> async def main() -> None:
    ...     pokemon: Pokemon = await client.getch_data(ExtensionEnum.Pokemon, "pokemon", 1)
    ...     print(pokemon.name)
    ...     await client.close()
    >>> asyncio.run(main())
    bulbasaur
    """
    if isinstance(ext, str) and (ext := str(ext).title()) not in ExtensionEnum.__members__:
        raise ValueError(f"Invalid extension: {ext}")
    categories = ExtensionEnum.get_categories(ext) if isinstance(ext, str) else ext.categories  # type: ignore
    if (category := category.lower().replace("_", "-")) not in categories:
        raise ValueError(f"Invalid category: {category}, valid categories: {categories}")
    category = category.replace("-", "_")
    ext_ = getattr(self, ext.lower()) if isinstance(ext, str) else getattr(self, ext.name.lower())
    get_, fetch_ = getattr(ext_, f"get_{category}"), getattr(ext_, f"fetch_{category}")
    return t.cast(BaseType, get_(id_) or await fetch_(id_))

async def ping(self) -> float:
    """
    Pings the PokeAPI and returns the latency.

    Returns
    -------
    float
        The latency of the PokeAPI.
    """
    return await self._http.ping()

def setup_hook(self) -> None:
    """
    The setup hook to be called after the client is created.
    This is called automatically when the client is created.
    It is not recommended to call this manually.
    """
    self._logger.info(f"Using cache size: {self._http.cache.max_size}")
    for extension in self.EXTENSIONS.iterdir():
        if extension.is_file() and extension.suffix == ".py":
            if "_" not in extension.stem:
                module = __import__(f"pokelance.ext.{extension.stem}", fromlist=["setup"])
                module.setup(self)
    self._logger.info("Setup complete")

async def wait_until_ready(self) -> None:
    """
    Waits until the http client caches all the endpoints.
    """
    await self._http.connect()
    self.logger.info("Waiting until ready...")
    while self._http._tasks_queue and self.cache_endpoints:
        await asyncio.sleep(0.5)
    self.logger.info("Ready!")