downloads ¤

def completed_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the completed length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The completed length string.
    """
    if human_readable:
        return human_readable_bytes(self.completed_length, delim=" ")
    return str(self.completed_length) + " B"

def copy_files(self, to_directory: str | Path, force: bool = False) -> bool:  # noqa: FBT001,FBT002
    """Copy downloaded files to another directory.

    Parameters:
        to_directory: The target directory to copy files into.
        force: Whether to move files even if download is not complete.

    Returns:
        Success or failure of the operation.
    """
    return self.api.copy_files([self], to_directory, force)[0]

def download_speed_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the download speed as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The download speed string.
    """
    if human_readable:
        return human_readable_bytes(self.download_speed, delim=" ", postfix="/s")
    return str(self.download_speed) + " B/s"

def eta_string(self, precision: int = 0) -> str:
    """Return the Estimated Time of Arrival as a string.

    Parameters:
        precision: The precision to use, see [aria2p.utils.human_readable_timedelta].

    Returns:
        The Estimated Time of Arrival as a string.
    """
    eta = self.eta

    if eta == timedelta.max:
        return "-"

    return human_readable_timedelta(eta, precision=precision)

def move(self, pos: int) -> int:
    """Move the download in the queue, relatively.

    Parameters:
        pos: Number of times to move.

    Returns:
        The new position of the download.
    """
    return self.api.move(self, pos)

def move_down(self, pos: int = 1) -> int:
    """Move the download down in the queue.

    Parameters:
        pos: Number of times to move down.

    Returns:
        The new position of the download.
    """
    return self.api.move_down(self, pos)

def move_files(self, to_directory: str | Path, force: bool = False) -> bool:  # noqa: FBT001,FBT002
    """Move downloaded files to another directory.

    Parameters:
        to_directory: The target directory to move files to.
        force: Whether to move files even if download is not complete.

    Returns:
        Success or failure of the operation.
    """
    return self.api.move_files([self], to_directory, force)[0]

def move_to(self, pos: int) -> int:
    """Move the download in the queue, absolutely.

    Parameters:
        pos: The absolute position in the queue to take.

    Returns:
        The new position of the download.
    """
    return self.api.move_to(self, pos)

def move_to_bottom(self) -> int:
    """Move the download to the bottom of the queue.

    Returns:
        The new position of the download.
    """
    return self.api.move_to_bottom(self)

def move_to_top(self) -> int:
    """Move the download to the top of the queue.

    Returns:
        The new position of the download.
    """
    return self.api.move_to_top(self)

def move_up(self, pos: int = 1) -> int:
    """Move the download up in the queue.

    Parameters:
        pos: Number of times to move up.

    Returns:
        The new position of the download.
    """
    return self.api.move_up(self, pos)

def pause(self, force: bool = False) -> bool:  # noqa: FBT001,FBT002
    """Pause the download.

    Parameters:
        force: Whether to force pause (don't contact servers).

    Returns:
        Always True (raises exception otherwise).

    Raises:
        ClientException: When pausing failed.
    """
    result = self.api.pause([self], force=force)[0]
    if not result:
        raise result  # type: ignore  # we know it's a ClientException
    return True

def piece_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the piece length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The piece length string.
    """
    if human_readable:
        return human_readable_bytes(self.piece_length, delim=" ")
    return str(self.piece_length) + " B"

def progress_string(self, digits: int = 2) -> str:
    """Return the progress percentage as string.

    Parameters:
        digits: Number of decimal digits to use.

    Returns:
        The progress percentage.
    """
    return f"{self.progress:.{digits}f}%"

def purge(self) -> bool:
    """Purge itself from the results.

    Returns:
        Success or failure of the operation.
    """
    return self.api.client.remove_download_result(self.gid) == "OK"

def remove(self, force: bool = False, files: bool = False) -> bool:  # noqa: FBT001,FBT002
    """Remove the download from the queue (even if active).

    Parameters:
        force: Whether to force removal.
        files: Whether to remove files as well.

    Returns:
        Always True (raises exception otherwise).

    Raises:
        ClientException: When removal failed.
    """
    result = self.api.remove([self], force=force, files=files)[0]
    if not result:
        raise result  # type: ignore  # we know it's a ClientException
    return True

def resume(self) -> bool:
    """Resume the download.

    Returns:
        Always True (raises exception otherwise).

    Raises:
        ClientException: When resuming failed.
    """
    result = self.api.resume([self])[0]
    if not result:
        raise result  # type: ignore  # we know it's a ClientException
    return True

def total_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the total length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The total length string.
    """
    if human_readable:
        return human_readable_bytes(self.total_length, delim=" ")
    return str(self.total_length) + " B"

def update(self) -> None:
    """Update the internal values of the download with more recent values."""
    self._struct = self.api.client.tell_status(self.gid)

    self._files = []
    self._name = ""
    self._bittorrent = None
    self._followed_by = None
    self._following = None
    self._belongs_to = None
    self._options = None

def update_options(self) -> None:
    """Re-fetch the options from the remote."""
    self._options = self.api.get_options(downloads=[self])[0]

def upload_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the upload length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The upload length string.
    """
    if human_readable:
        return human_readable_bytes(self.upload_length, delim=" ")
    return str(self.upload_length) + " B"

def upload_speed_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the upload speed as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The upload speed string.
    """
    if human_readable:
        return human_readable_bytes(self.upload_speed, delim=" ", postfix="/s")
    return str(self.upload_speed) + " B/s"

def verified_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the verified length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The verified length string.
    """
    if human_readable:
        return human_readable_bytes(self.verified_length, delim=" ")
    return str(self.verified_length) + " B"

def completed_length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the completed length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The completed length string.
    """
    if human_readable:
        return human_readable_bytes(self.completed_length, delim=" ")
    return str(self.completed_length) + " B"

def length_string(self, human_readable: bool = True) -> str:  # noqa: FBT001,FBT002
    """Return the length as string.

    Parameters:
        human_readable: Return in human readable format or not.

    Returns:
        The length string.
    """
    if human_readable:
        return human_readable_bytes(self.length, delim=" ")
    return str(self.length) + " B"