def get_image_tag(self,
                      requirements_option: RequirementsOptions,
                      requirements_hash: Optional[str],
                      dependencies: Optional[List[str]]) -> str:
        """ Returns the tag for images with the dependencies and requirements installed.

        64-byte hexadecimal strings cannot be used as docker tags, so the prefixes are necessary.
        Double hashing the dependencies and requirements hash to make the final tag shorter.

        Prefixes:

        * Image type:

          * i – Inherited image
          * a – Arca base image

        * Requirements:

          * r – Does have some kind of requirements
          * s – Doesn't have requirements

        * Dependencies:

          * d – Does have dependencies
          * e – Doesn't have dependencies

        Possible outputs:

        * Inherited images:

          * `ise` – no requirements
          * `ide_<hash(requirements)>` – with requirements

        * From Arca base image:

          * `<Arca version>_<Python version>_ase` – no requirements and no dependencies
          * `<Arca version>_<Python version>_asd_<hash(dependencies)>` – only dependencies
          * `<Arca version>_<Python version>_are_<hash(requirements)>` – only requirements
          * `<Arca version>_<Python version>_ard_<hash(hash(dependencies) + hash(requirements))>`
            – both requirements and dependencies

        """
        prefix = ""

        if self.inherit_image is None:
            prefix = "{}_{}_".format(arca.__version__, self.get_python_version())

        prefix += "i" if self.inherit_image is not None else "a"
        prefix += "r" if requirements_option != RequirementsOptions.no_requirements else "s"
        prefix += "d" if dependencies is not None else "e"

        if self.inherit_image is not None:
            if requirements_hash:
                return prefix + "_" + requirements_hash
            return prefix

        if dependencies is None:
            dependencies_hash = ""
        else:
            dependencies_hash = self.get_dependencies_hash(dependencies)

        if requirements_hash and dependencies_hash:
            return prefix + "_" + hashlib.sha256(bytes(requirements_hash + dependencies_hash, "utf-8")).hexdigest()
        elif requirements_hash:
            return f"{prefix}_{requirements_hash}"
        elif dependencies_hash:
            return f"{prefix}_{dependencies_hash}"
        else:
            return prefix