crfm-helm 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

helm/clients/image_generation/dalle_mini_client.py

@@ -0,0 +1,190 @@
+from typing import Any, Dict, List
+
+import numpy as np
+from functools import partial
+
+from helm.common.cache import CacheConfig, Cache
+from helm.common.file_caches.file_cache import FileCache
+from helm.common.hierarchical_logger import hlog, htrack_block
+from helm.common.optional_dependencies import handle_module_not_found_error
+from helm.common.request import Request, RequestResult, GeneratedOutput, wrap_request_time
+from helm.common.tokenization_request import (
+    DecodeRequest,
+    DecodeRequestResult,
+    TokenizationRequest,
+    TokenizationRequestResult,
+)
+from helm.clients.client import Client, CachingClient
+from .image_generation_client_utils import get_single_image_multimedia_object
+
+
+class DALLEMiniClient(Client):
+    """
+    Source: https://github.com/borisdayma/dalle-mini, https://github.com/patil-suraj/vqgan-jax
+    """
+
+    VQGAN_REPO = "dalle-mini/vqgan_imagenet_f16_16384"
+    VQGAN_COMMIT_ID = "e93a26e7707683d349bf5d5c41c5b0ef69b677a9"
+
+    def __init__(self, cache_config: CacheConfig, file_cache: FileCache):
+        self._cache = Cache(cache_config)
+        self._file_cache: FileCache = file_cache
+
+        self._model_engine_to_model = {}
+
+    def _get_model(self, model_engine: str):
+        """
+        Initialize the model based on the model name.
+        Cache the model, so it doesn't get reinitialize for a new request.
+        """
+        try:
+            import jax.numpy as jnp
+            from flax.jax_utils import replicate
+
+            from helm.clients.image_generation.dalle_mini.vqgan_jax.modeling_flax_vqgan import VQModel
+            from helm.clients.image_generation.dalle_mini import DalleBart, DalleBartProcessor
+        except ModuleNotFoundError as e:
+            handle_module_not_found_error(e, ["heim"])
+
+        if model_engine not in self._model_engine_to_model:
+            model_name: str
+            if model_engine == "dalle-mini":
+                model_name = "dalle-mini/dalle-mini/mini-1:v0"
+            elif model_engine == "dalle-mega":
+                model_name = "dalle-mini/dalle-mini/mega-1-fp16:latest"
+            else:
+                raise ValueError(f"Unhandled model: {model_engine}")
+
+            model, params = DalleBart.from_pretrained(model_name, revision=None, dtype=jnp.float16, _do_init=False)
+            processor = DalleBartProcessor.from_pretrained(model_name, revision=None)
+            vqgan, vqgan_params = VQModel.from_pretrained(
+                self.VQGAN_REPO, revision=self.VQGAN_COMMIT_ID, _do_init=False
+            )
+            params = replicate(params)
+            vqgan_params = replicate(vqgan_params)
+            self._model_engine_to_model[model_engine] = [model, params, processor, vqgan, vqgan_params]
+        return self._model_engine_to_model[model_engine]
+
+    def make_request(self, request: Request) -> RequestResult:
+        try:
+            import jax
+            from flax.training.common_utils import shard_prng_key
+            from flax.jax_utils import replicate
+            from PIL import Image
+        except ModuleNotFoundError as e:
+            handle_module_not_found_error(e, ["heim"])
+
+        raw_request = {
+            "prompt": request.prompt,
+            "top_k": None,
+            "top_p": None,
+            "temperature": None,
+            "condition_scale": 10.0,
+        }
+
+        try:
+
+            def _inference(
+                model, params, vqgan, vqgan_params, tokenized_prompt, subkey, top_k, top_p, temperature, condition_scale
+            ):
+                @partial(jax.pmap, axis_name="batch", static_broadcasted_argnums=(3, 4, 5, 6))
+                def p_generate(tokenized_prompt, key, params, top_k, top_p, temperature, condition_scale):
+                    return model.generate(
+                        **tokenized_prompt,
+                        prng_key=key,
+                        params=params,
+                        top_k=top_k,
+                        top_p=top_p,
+                        temperature=temperature,
+                        condition_scale=condition_scale,
+                    )
+
+                @partial(jax.pmap, axis_name="batch")
+                def p_decode(indices, params):
+                    return vqgan.decode_code(indices, params=params)
+
+                # generate images
+                encoded_images = p_generate(
+                    tokenized_prompt,
+                    shard_prng_key(subkey),
+                    params,
+                    top_k,
+                    top_p,
+                    temperature,
+                    condition_scale,
+                )
+                # remove BOS
+                encoded_images = encoded_images.sequences[..., 1:]
+                # decode images
+                decoded_images = p_decode(encoded_images, vqgan_params)
+                decoded_images = decoded_images.clip(0.0, 1.0).reshape((-1, 256, 256, 3))
+                return decoded_images
+
+            def do_it() -> Dict[str, Any]:
+                prompt: str = request.prompt
+
+                with htrack_block(f"Generating images for prompt: {prompt}"):
+                    model, params, processor, vqgan, vqgan_params = self._get_model(request.model_engine)
+                    tokenized_prompts = processor([prompt])
+                    tokenized_prompt = replicate(tokenized_prompts)
+
+                    images: List[Image] = []
+                    key = jax.random.PRNGKey(0)
+                    for _ in range(request.num_completions):
+                        key, subkey = jax.random.split(key)
+                        image = _inference(
+                            model,
+                            params,
+                            vqgan,
+                            vqgan_params,
+                            tokenized_prompt,
+                            subkey,
+                            raw_request["top_k"],
+                            raw_request["top_p"],
+                            raw_request["temperature"],
+                            raw_request["condition_scale"],
+                        )[0]
+                        image = Image.fromarray(np.asarray(image * 255, dtype=np.uint8))
+                        images.append(image)
+
+                    assert (
+                        len(images) == request.num_completions
+                    ), f"Expected {request.num_completions} images, but got {len(images)}"
+
+                    result = {"file_locations": []}
+                    for image in images:
+                        # Write out the image to a file and save the path
+                        file_location: str = self._file_cache.get_unique_file_location()
+                        image.save(file_location)
+                        hlog(f"Image saved at {file_location}.")
+                        result["file_locations"].append(file_location)
+                    return result
+
+            # Include the model name and number of completions in the cache key
+            cache_key = CachingClient.make_cache_key(
+                {"model": request.model_engine, "n": request.num_completions, **raw_request}, request
+            )
+            results, cached = self._cache.get(cache_key, wrap_request_time(do_it))
+        except RuntimeError as e:
+            error: str = f"DALLEMiniClient error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+        completions: List[GeneratedOutput] = [
+            GeneratedOutput(
+                text="", logprob=0, tokens=[], multimodal_content=get_single_image_multimedia_object(file_location)
+            )
+            for file_location in results["file_locations"]
+        ]
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=results["request_time"],
+            completions=completions,
+            embedding=[],
+        )
+
+    def tokenize(self, request: TokenizationRequest) -> TokenizationRequestResult:
+        raise NotImplementedError("This client does not support tokenizing.")
+
+    def decode(self, request: DecodeRequest) -> DecodeRequestResult:
+        raise NotImplementedError("This client does not support decoding.")

helm/clients/image_generation/deep_floyd_client.py

@@ -0,0 +1,78 @@
+from typing import List, Dict
+
+from helm.common.cache import Cache, CacheConfig
+from helm.common.request import Request, RequestResult, GeneratedOutput
+from helm.common.tokenization_request import (
+    TokenizationRequest,
+    TokenizationRequestResult,
+    DecodeRequest,
+    DecodeRequestResult,
+)
+from helm.clients.client import Client, CachingClient
+from .image_generation_client_utils import get_single_image_multimedia_object
+
+
+class DeepFloydClient(Client):
+    """
+    Client for [DeepFloyd image generation models](https://huggingface.co/docs/diffusers/v0.16.0/api/pipelines/ifs).
+    We rely on offline eval for now due to conflicting dependencies (e.g., Transformers).
+    """
+
+    SUPPORTED_MODELS: List[str] = ["IF-I-M-v1.0", "IF-I-L-v1.0", "IF-I-XL-v1.0"]
+
+    @staticmethod
+    def convert_to_raw_request(request: Request) -> Dict:
+        # Use default hyperparameters for everything else
+        raw_request: Dict = {
+            "model": request.model_engine,
+            "n": request.num_completions,
+            "prompt": request.prompt,
+            "request_type": "image-model-inference",
+        }
+        if request.random is not None:
+            raw_request["random"] = request.random
+        return raw_request
+
+    def __init__(self, cache_config: CacheConfig):
+        self._cache = Cache(cache_config)
+        self._promptist_model = None
+        self._promptist_tokenizer = None
+
+    def make_request(self, request: Request) -> RequestResult:
+        if request.model_engine not in self.SUPPORTED_MODELS:
+            raise ValueError(f"Unsupported model: {request.model_engine}")
+
+        raw_request = DeepFloydClient.convert_to_raw_request(request)
+        cache_key = CachingClient.make_cache_key(raw_request, request)
+
+        try:
+
+            def fail():
+                raise RuntimeError(
+                    f"The result has not been uploaded to the cache for the following request: {cache_key}"
+                )
+
+            response, cached = self._cache.get(cache_key, fail)
+        except RuntimeError as e:
+            error: str = f"DeepFloyd Client error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+        completions: List[GeneratedOutput] = [
+            GeneratedOutput(
+                text="", logprob=0, tokens=[], multimodal_content=get_single_image_multimedia_object(file_path)
+            )
+            for file_path in response["images"]
+        ]
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=response["total_inference_time"],
+            completions=completions,
+            embedding=[],
+        )
+
+    def tokenize(self, request: TokenizationRequest) -> TokenizationRequestResult:
+        raise NotImplementedError("This client does not support tokenizing.")
+
+    def decode(self, request: DecodeRequest) -> DecodeRequestResult:
+        raise NotImplementedError("This client does not support decoding.")

helm/clients/image_generation/huggingface_diffusers_client.py

@@ -0,0 +1,249 @@
+from threading import Lock
+from typing import Any, Dict, List, Optional
+
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+from helm.common.cache import CacheConfig, Cache
+from helm.common.file_caches.file_cache import FileCache
+from helm.common.gpu_utils import get_torch_device_name, is_cuda_available
+from helm.common.hierarchical_logger import hlog, htrack_block
+from helm.common.optional_dependencies import handle_module_not_found_error
+from helm.common.request import Request, RequestResult, GeneratedOutput, wrap_request_time
+from helm.common.tokenization_request import (
+    DecodeRequest,
+    DecodeRequestResult,
+    TokenizationRequest,
+    TokenizationRequestResult,
+)
+from helm.clients.client import Client, CachingClient
+from .image_generation_client_utils import get_single_image_multimedia_object
+
+
+_models_lock: Lock = Lock()
+_models: Dict[str, Any] = {}
+
+
+class HuggingFaceDiffusersClient(Client):
+    def __init__(self, hf_auth_token: str, cache_config: CacheConfig, file_cache: FileCache):
+        self._hf_auth_token: str = hf_auth_token
+        self._cache = Cache(cache_config)
+        self._file_cache: FileCache = file_cache
+
+        self._promptist_model = None
+        self._promptist_tokenizer = None
+
+    def _get_diffuser(self, request: Request):
+        """
+        Initialize the Diffusion Pipeline based on the model name.
+        Cache the model, so it doesn't get reinitialize for a new request.
+        """
+        try:
+            from diffusers import DiffusionPipeline
+        except ModuleNotFoundError as e:
+            handle_module_not_found_error(e, ["heim"])
+
+        global _models_lock
+        global _models
+
+        with _models_lock:
+            model_engine: str = request.model_engine
+
+            if model_engine not in _models:
+                huggingface_model_name: str
+                if model_engine in ["stable-diffusion-v1-4", "promptist-stable-diffusion-v1-4"]:
+                    huggingface_model_name = "CompVis/stable-diffusion-v1-4"
+                elif model_engine == "stable-diffusion-v1-5":
+                    huggingface_model_name = "runwayml/stable-diffusion-v1-5"
+                elif model_engine == "stable-diffusion-v2-base":
+                    huggingface_model_name = "stabilityai/stable-diffusion-2-base"
+                elif model_engine == "stable-diffusion-v2-1-base":
+                    huggingface_model_name = "stabilityai/stable-diffusion-2-1-base"
+                elif model_engine == "dreamlike-diffusion-v1-0":
+                    huggingface_model_name = "dreamlike-art/dreamlike-diffusion-1.0"
+                elif model_engine == "dreamlike-photoreal-v2-0":
+                    huggingface_model_name = "dreamlike-art/dreamlike-photoreal-2.0"
+                elif model_engine == "openjourney-v1-0":
+                    huggingface_model_name = "prompthero/openjourney"
+                elif model_engine == "openjourney-v2-0":
+                    huggingface_model_name = "prompthero/openjourney-v2"
+                elif model_engine == "redshift-diffusion":
+                    huggingface_model_name = "nitrosocke/redshift-diffusion"
+                elif "stable-diffusion-safe" in model_engine:
+                    huggingface_model_name = "AIML-TUDA/stable-diffusion-safe"
+                elif model_engine == "vintedois-diffusion-v0-1":
+                    huggingface_model_name = "22h/vintedois-diffusion-v0-1"
+                elif model_engine == "SSD-1B":
+                    huggingface_model_name = "segmind/SSD-1B"
+                else:
+                    huggingface_model_name = request.model
+
+                pipeline = DiffusionPipeline.from_pretrained(
+                    huggingface_model_name,
+                    torch_dtype=torch.float16 if is_cuda_available() else torch.float,
+                    use_auth_token=self._hf_auth_token,
+                )
+                _models[model_engine] = pipeline.to(get_torch_device_name())
+            return _models[model_engine]
+
+    def make_request(self, request: Request) -> RequestResult:
+        try:
+            from diffusers import DiffusionPipeline
+            from diffusers.pipelines.stable_diffusion_safe import SafetyConfig
+        except ModuleNotFoundError as e:
+            handle_module_not_found_error(e, ["heim"])
+
+        raw_request = {
+            "prompt": request.prompt,
+            # Setting this to a higher value can cause CUDA OOM
+            # Fix it to 1 and generate an image `request.num_completions` times
+            "num_images_per_prompt": 1,
+        }
+
+        assert request.image_generation_parameters is not None
+        if request.image_generation_parameters.guidance_scale is not None:
+            raw_request["guidance_scale"] = request.image_generation_parameters.guidance_scale
+        if request.image_generation_parameters.diffusion_denoising_steps is not None:
+            raw_request["num_inference_steps"] = request.image_generation_parameters.diffusion_denoising_steps
+        if request.image_generation_parameters.output_image_width is not None:
+            raw_request["width"] = request.image_generation_parameters.output_image_width
+        if request.image_generation_parameters.output_image_height is not None:
+            raw_request["height"] = request.image_generation_parameters.output_image_height
+
+        # Add the additional pre-configured parameters for Safe Stable Diffusion
+        if request.model_engine == "stable-diffusion-safe-weak":
+            raw_request = {**raw_request, **SafetyConfig.WEAK}
+        elif request.model_engine == "stable-diffusion-safe-medium":
+            raw_request = {**raw_request, **SafetyConfig.MEDIUM}
+        elif request.model_engine == "stable-diffusion-safe-strong":
+            raw_request = {**raw_request, **SafetyConfig.STRONG}
+        elif request.model_engine == "stable-diffusion-safe-max":
+            raw_request = {**raw_request, **SafetyConfig.MAX}
+
+        try:
+
+            def replace_prompt(request_to_update: Dict, new_prompt: str) -> Dict:
+                new_request: Dict = dict(request_to_update)
+                assert "prompt" in new_request
+                new_request["prompt"] = new_prompt
+                return new_request
+
+            def do_it() -> Dict[str, Any]:
+                prompt: str = request.prompt
+
+                with htrack_block(f"Generating images for prompt: {prompt}"):
+                    diffuser: DiffusionPipeline = self._get_diffuser(request)
+                    promptist_prompt: Optional[str] = None
+
+                    images = []
+                    for _ in range(request.num_completions):
+                        if request.model_engine == "promptist-stable-diffusion-v1-4":
+                            promptist_prompt = self._generate_promptist_prompt(prompt)
+                            hlog(f"Promptist: {prompt} -> {promptist_prompt}")
+                            image = diffuser(**replace_prompt(raw_request, promptist_prompt)).images[0]  # type: ignore
+                        elif request.model_engine == "openjourney-v1-0":
+                            # It is required to include "mdjrny-v4 style" in prompt for Openjourney v1
+                            image = diffuser(
+                                **replace_prompt(raw_request, f"mdjrny-v4 style {prompt}")  # type: ignore
+                            ).images[0]
+                        elif request.model_engine == "redshift-diffusion":
+                            # It is required to include "redshift style" to generate 3D images
+                            image = diffuser(
+                                **replace_prompt(raw_request, f"redshift style {prompt}")  # type: ignore
+                            ).images[0]
+                        else:
+                            image = diffuser(**raw_request).images[0]  # type: ignore
+                        images.append(image)
+
+                    assert (
+                        len(images) == request.num_completions
+                    ), f"Expected {request.num_completions} images, but got {len(images)}"
+
+                    result: Dict = {"file_locations": []}
+                    if promptist_prompt is not None:
+                        # Save the Promptist version of the prompts in the cache, just in case we need it later
+                        result["promptist_prompt"] = promptist_prompt
+
+                    for image in images:
+                        # Write out the image to a file and save the path
+                        file_location: str = self._file_cache.generate_unique_new_file_path()  # type: ignore
+                        image.save(file_location)
+                        hlog(f"Image saved at {file_location}")
+                        result["file_locations"].append(file_location)
+                    return result
+
+            # Include the model name and number of completions in the cache key
+            cache_key = CachingClient.make_cache_key(
+                {"model": request.model_engine, "n": request.num_completions, **raw_request}, request
+            )
+            results, cached = self._cache.get(cache_key, wrap_request_time(do_it))
+        except RuntimeError as ex:
+            error: str = f"HuggingFaceDiffusersClient error: {ex}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+        completions: List[GeneratedOutput] = [
+            GeneratedOutput(
+                text="", logprob=0, tokens=[], multimodal_content=get_single_image_multimedia_object(file_location)
+            )
+            for file_location in results["file_locations"]
+        ]
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=results["request_time"],
+            completions=completions,
+            embedding=[],
+        )
+
+    def _generate_promptist_prompt(self, prompt: str) -> str:
+        """
+        Generate a better version of the prompt with Promptist.
+        Promptist was trained specifically with CompVis/stable-diffusion-v1-4.
+        Adapted from https://huggingface.co/spaces/microsoft/Promptist/blob/main/app.py.
+        """
+
+        def load_promptist():
+            prompter_model = AutoModelForCausalLM.from_pretrained("microsoft/Promptist")
+            tokenizer = AutoTokenizer.from_pretrained("gpt2")
+            tokenizer.pad_token = tokenizer.eos_token
+            tokenizer.padding_side = "left"
+            return prompter_model, tokenizer
+
+        def generate(plain_text: str) -> str:
+            if self._promptist_model is None or self._promptist_tokenizer is None:
+                self._promptist_model, self._promptist_tokenizer = load_promptist()
+            assert self._promptist_model is not None
+            assert self._promptist_tokenizer is not None
+
+            input_ids = self._promptist_tokenizer(f"{plain_text.strip()} Rephrase:", return_tensors="pt").input_ids
+            eos_id = self._promptist_tokenizer.eos_token_id
+            # Used the same hyperparameters from the example
+            outputs = self._promptist_model.generate(
+                input_ids,
+                do_sample=False,
+                max_new_tokens=75,
+                num_beams=8,
+                num_return_sequences=8,
+                eos_token_id=eos_id,
+                pad_token_id=eos_id,
+                length_penalty=-1.0,
+            )
+            output_texts: List[str] = self._promptist_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+
+            for output_text in output_texts:
+                res: str = output_text.replace(f"{plain_text} Rephrase:", "").strip()
+                # The Promptist model sometimes generates empty string results.
+                # Return the first non-empty string result.
+                if len(res) > 0:
+                    return res
+
+            # If all fails, just return the original text.
+            return plain_text
+
+        return generate(prompt)
+
+    def tokenize(self, request: TokenizationRequest) -> TokenizationRequestResult:
+        raise NotImplementedError("This client does not support tokenizing.")
+
+    def decode(self, request: DecodeRequest) -> DecodeRequestResult:
+        raise NotImplementedError("This client does not support decoding.")

helm/clients/image_generation/image_generation_client_utils.py

@@ -0,0 +1,9 @@
+from helm.common.media_object import MediaObject, MultimediaObject
+
+
+def get_single_image_multimedia_object(image_location: str) -> MultimediaObject:
+    """
+    Returns a `MultimediaObject` containing a single image file used for text-to-image generation clients.
+    """
+    file_extension: str = image_location.split(".")[-1]
+    return MultimediaObject([MediaObject(content_type=f"image/{file_extension}", location=image_location)])

helm/clients/image_generation/lexica_client.py

@@ -0,0 +1,86 @@
+from typing import Any, List, Dict, Union
+import base64
+import requests
+import urllib.parse
+
+from helm.common.cache import CacheConfig, Cache
+from helm.common.file_caches.file_cache import FileCache
+from helm.common.images_utils import encode_base64
+from helm.common.request import Request, RequestResult, GeneratedOutput, wrap_request_time
+from helm.common.tokenization_request import (
+    TokenizationRequest,
+    TokenizationRequestResult,
+    DecodeRequest,
+    DecodeRequestResult,
+)
+from helm.clients.client import Client, CachingClient
+from .image_generation_client_utils import get_single_image_multimedia_object
+
+
+class LexicaClient(Client):
+    """
+    Client for Lexica API. Does not support image generation.
+    """
+
+    def __init__(self, cache_config: CacheConfig, file_cache: FileCache):
+        self.cache = Cache(cache_config)
+        self.file_cache: FileCache = file_cache
+
+    def make_request(self, request: Request) -> RequestResult:
+        """
+        Retrieves images through Lexica's search API (https://lexica.art/docs).
+        The search API is powered by CLIP to fetch the most relevant images for a given query.
+        """
+        if request.model_engine != "search-stable-diffusion-1.5":
+            # Only Stable Diffusion 1.5 is supported at the moment
+            raise ValueError(f"Invalid model: {request.model_engine}")
+
+        raw_request: Dict[str, Union[str, int]] = {
+            "model": request.model_engine,
+            "prompt": request.prompt,
+            "n": request.num_completions,
+        }
+        cache_key = CachingClient.make_cache_key(raw_request, request)
+
+        try:
+
+            def do_it() -> Dict[str, Any]:
+                num_completions: int = int(raw_request["n"])
+                result = requests.get(
+                    f"https://lexica.art/api/v1/search?{urllib.parse.urlencode({'q': request.prompt})}"
+                ).json()
+                assert "images" in result, f"Invalid response: {result} from prompt: {request.prompt}"
+                assert len(result["images"]) >= num_completions, "Did not retrieve enough images"
+
+                image_locations: List[str] = []
+                # Most relevant images are at the top of the list
+                for image in result["images"][:num_completions]:
+                    # Write out the image to a file and save the location
+                    image_base64: str = encode_base64(image["src"])
+                    image_locations.append(self.file_cache.store(lambda: base64.b64decode(image_base64)))
+                return {"image_locations": image_locations}
+
+            response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
+        except RuntimeError as e:
+            error: str = f"LexicaClient error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+        completions: List[GeneratedOutput] = [
+            GeneratedOutput(
+                text="", logprob=0, tokens=[], multimodal_content=get_single_image_multimedia_object(location)
+            )
+            for location in response["image_locations"]
+        ]
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=response["request_time"],
+            completions=completions,
+            embedding=[],
+        )
+
+    def tokenize(self, request: TokenizationRequest) -> TokenizationRequestResult:
+        raise NotImplementedError("This client does not support tokenizing.")
+
+    def decode(self, request: DecodeRequest) -> DecodeRequestResult:
+        raise NotImplementedError("This client does not support decoding.")