




from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


a_				=     logging.get_logger(__name__)  # pylint: disable=invalid-name

a_				=     "\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n        >>> from diffusers.utils import load_image\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior.to(\"cuda\")\n\n        >>> prompt = \"A red cartoon frog, 4k\"\n        >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n        >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-decoder\", torch_dtype=torch.float16\n        ... )\n        >>> pipe.to(\"cuda\")\n\n        >>> init_image = load_image(\n        ...     \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n        ...     \"/kandinsky/frog.png\"\n        ... )\n\n        >>> image = pipe(\n        ...     image=init_image,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ...     strength=0.2,\n        ... ).images\n\n        >>> image[0].save(\"red_frog.png\")\n        ```\n"




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_					,     lowercase_=8      )       ->	Tuple:

    """simple docstring"""


    __UpperCamelCase  		=						height // scale_factor**2
    if height % scale_factor**2 != 0:
        new_height += 1
    __UpperCamelCase  		=						width // scale_factor**2
    if width % scale_factor**2 != 0:
        new_width += 1
    return new_height * scale_factor, new_width * scale_factor




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_=5_12					,     lowercase_=5_12      )       ->	Optional[int]:

    """simple docstring"""


    __UpperCamelCase  		=						pil_image.resize((w, h)					,     resample=Image.BICUBIC					,     reducing_gap=1      )
    __UpperCamelCase  		=						np.array(pil_image.convert('''RGB'''      )      )
    __UpperCamelCase  		=						arr.astype(np.floataa      ) / 127.5 - 1
    __UpperCamelCase  		=						np.transpose(lowercase_					,     [2, 0, 1]      )
    __UpperCamelCase  		=						torch.from_numpy(lowercase_      ).unsqueeze(0      )
    return image


class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      def __init__(     self					: Optional[int] ,       snake_case					: UNetaDConditionModel ,       snake_case					: DDPMScheduler ,       snake_case					: VQModel ,       ):
          super().__init__()

          self.register_modules(
              unet=snake_case ,       scheduler=snake_case ,       movq=snake_case ,       )
          __UpperCamelCase  		=						2 ** (len(self.movq.config.block_out_channels				) - 1)







      def       snake_case	(     self					: int ,       snake_case					: Optional[Any] ,       snake_case					: str ,       snake_case					: Tuple				):
          # get the original timestep using init_timestep
          __UpperCamelCase  		=						min(int(num_inference_steps * strength				) ,       snake_case				)

          __UpperCamelCase  		=						max(num_inference_steps - init_timestep ,       0				)
          __UpperCamelCase  		=						self.scheduler.timesteps[t_start:]

          return timesteps, num_inference_steps - t_start







      def       snake_case	(     self					: str ,       snake_case					: Dict ,       snake_case					: List[str] ,       snake_case					: Any ,       snake_case					: str ,       snake_case					: Dict ,       snake_case					: Optional[Any] ,       snake_case					: int=None				):
          if not isinstance(snake_case ,       (torch.Tensor, PIL.Image.Image, list)				):
              raise ValueError(
                  F"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(snake_case				)}"				)

          __UpperCamelCase  		=						image.to(device=snake_case ,       dtype=snake_case				)

          __UpperCamelCase  		=						batch_size * num_images_per_prompt

          if image.shape[1] == 4:
              __UpperCamelCase  		=						image

          else:
              if isinstance(snake_case ,       snake_case				) and len(snake_case				) != batch_size:
                  raise ValueError(
                      F"You have passed a list of generators of length {len(snake_case				)}, but requested an effective batch"
                      F" size of {batch_size}. Make sure the batch size matches the length of the generators."				)

              elif isinstance(snake_case ,       snake_case				):
                  __UpperCamelCase  		=						[
                      self.movq.encode(image[i : i + 1]				).latent_dist.sample(generator[i]				) for i in range(snake_case				)
                  ]
                  __UpperCamelCase  		=						torch.cat(snake_case ,       dim=0				)
              else:
                  __UpperCamelCase  		=						self.movq.encode(snake_case				).latent_dist.sample(snake_case				)

              __UpperCamelCase  		=						self.movq.config.scaling_factor * init_latents

          __UpperCamelCase  		=						torch.cat([init_latents] ,       dim=0				)

          __UpperCamelCase  		=						init_latents.shape
          __UpperCamelCase  		=						randn_tensor(snake_case ,       generator=snake_case ,       device=snake_case ,       dtype=snake_case				)

          # get latents
          __UpperCamelCase  		=						self.scheduler.add_noise(snake_case ,       snake_case ,       snake_case				)

          __UpperCamelCase  		=						init_latents

          return latents







      def       snake_case	(     self					: Optional[int] ,       snake_case					: List[str]=0				):
          if is_accelerate_available():
              from accelerate import cpu_offload
          else:
              raise ImportError('''Please install accelerate via `pip install accelerate`'''				)

          __UpperCamelCase  		=						torch.device(F"cuda:{gpu_id}"				)

          __UpperCamelCase  		=						[
              self.unet,
              self.movq,
          ]
          for cpu_offloaded_model in models:
              if cpu_offloaded_model is not None:
                  cpu_offload(snake_case ,       snake_case				)







      def       snake_case	(     self					: Dict ,       snake_case					: Dict=0				):
          if is_accelerate_available() and is_accelerate_version('''>=''' ,       '''0.17.0.dev0'''				):
              from accelerate import cpu_offload_with_hook
          else:
              raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''				)

          __UpperCamelCase  		=						torch.device(F"cuda:{gpu_id}"				)

          if self.device.type != "cpu":
              self.to('''cpu''' ,       silence_dtype_warnings=snake_case				)
              torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

          __UpperCamelCase  		=						None
          for cpu_offloaded_model in [self.unet, self.movq]:
              __UpperCamelCase		,      __UpperCamelCase  		=						cpu_offload_with_hook(snake_case ,       snake_case ,       prev_module_hook=snake_case				)

          # We'll offload the last model manually.
          __UpperCamelCase  		=						hook







      @property
      # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
      def       snake_case	(     self					: Dict				):
          if not hasattr(self.unet ,       '''_hf_hook'''				):
              return self.device
          for module in self.unet.modules():
              if (
                  hasattr(snake_case ,       '''_hf_hook'''				)
                  and hasattr(module._hf_hook ,       '''execution_device'''				)
                  and module._hf_hook.execution_device is not None
              ):
                  return torch.device(module._hf_hook.execution_device				)
          return self.device







      @torch.no_grad()
      @replace_example_docstring(snake_case				)
      def __call__(     self					: Union[str, Any] ,       snake_case					: Union[torch.FloatTensor, List[torch.FloatTensor]] ,       snake_case					: Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]] ,       snake_case					: Union[torch.FloatTensor, List[torch.FloatTensor]] ,       snake_case					: int = 512 ,       snake_case					: int = 512 ,       snake_case					: int = 100 ,       snake_case					: float = 4.0 ,       snake_case					: float = 0.3 ,       snake_case					: int = 1 ,       snake_case					: Optional[Union[torch.Generator, List[torch.Generator]]] = None ,       snake_case					: Optional[str] = "pil" ,       snake_case					: bool = True ,       ):
          __UpperCamelCase  		=						self._execution_device

          __UpperCamelCase  		=						guidance_scale > 1.0

          if isinstance(snake_case ,       snake_case				):
              __UpperCamelCase  		=						torch.cat(snake_case ,       dim=0				)
          __UpperCamelCase  		=						image_embeds.shape[0]
          if isinstance(snake_case ,       snake_case				):
              __UpperCamelCase  		=						torch.cat(snake_case ,       dim=0				)

          if do_classifier_free_guidance:
              __UpperCamelCase  		=						image_embeds.repeat_interleave(snake_case ,       dim=0				)
              __UpperCamelCase  		=						negative_image_embeds.repeat_interleave(snake_case ,       dim=0				)

          __UpperCamelCase  		=						torch.cat([negative_image_embeds, image_embeds] ,       dim=0				).to(dtype=self.unet.dtype ,       device=snake_case				)

          if not isinstance(snake_case ,       snake_case				):
              __UpperCamelCase  		=						[image]
          if not all(isinstance(snake_case ,       (PIL.Image.Image, torch.Tensor)				) for i in image				):
              raise ValueError(
                  F"Input is in incorrect format: {[type(snake_case				) for i in image]}. Currently, we only support  PIL image and pytorch tensor"				)

          __UpperCamelCase  		=						torch.cat([prepare_image(snake_case ,       snake_case ,       snake_case				) for i in image] ,       dim=0				)
          __UpperCamelCase  		=						image.to(dtype=image_embeds.dtype ,       device=snake_case				)

          __UpperCamelCase  		=						self.movq.encode(snake_case				)['''latents''']
          __UpperCamelCase  		=						latents.repeat_interleave(snake_case ,       dim=0				)
          self.scheduler.set_timesteps(snake_case ,       device=snake_case				)
          __UpperCamelCase		,      __UpperCamelCase  		=						self.get_timesteps(snake_case ,       snake_case ,       snake_case				)
          __UpperCamelCase  		=						timesteps[:1].repeat(batch_size * num_images_per_prompt				)
          __UpperCamelCase		,      __UpperCamelCase  		=						downscale_height_and_width(snake_case ,       snake_case ,       self.movq_scale_factor				)
          __UpperCamelCase  		=						self.prepare_latents(
              snake_case ,       snake_case ,       snake_case ,       snake_case ,       image_embeds.dtype ,       snake_case ,       snake_case				)
          for i, t in enumerate(self.progress_bar(snake_case				)				):
              # expand the latents if we are doing classifier free guidance
              __UpperCamelCase  		=						torch.cat([latents] * 2				) if do_classifier_free_guidance else latents

              __UpperCamelCase  		=						{'''image_embeds''': image_embeds}
              __UpperCamelCase  		=						self.unet(
                  sample=snake_case ,       timestep=snake_case ,       encoder_hidden_states=snake_case ,       added_cond_kwargs=snake_case ,       return_dict=snake_case ,       )[0]

              if do_classifier_free_guidance:
                  __UpperCamelCase		,      __UpperCamelCase  		=						noise_pred.split(latents.shape[1] ,       dim=1				)
                  __UpperCamelCase		,      __UpperCamelCase  		=						noise_pred.chunk(2				)
                  __UpperCamelCase		,      __UpperCamelCase  		=						variance_pred.chunk(2				)
                  __UpperCamelCase  		=						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
                  __UpperCamelCase  		=						torch.cat([noise_pred, variance_pred_text] ,       dim=1				)

              if not (
                  hasattr(self.scheduler.config ,       '''variance_type'''				)
                  and self.scheduler.config.variance_type in ["learned", "learned_range"]
              ):
                  __UpperCamelCase		,      __UpperCamelCase  		=						noise_pred.split(latents.shape[1] ,       dim=1				)

              # compute the previous noisy sample x_t -> x_t-1
              __UpperCamelCase  		=						self.scheduler.step(
                  snake_case ,       snake_case ,       snake_case ,       generator=snake_case ,       )[0]

          # post-processing
          __UpperCamelCase  		=						self.movq.decode(snake_case ,       force_not_quantize=snake_case				)['''sample''']

          if output_type not in ["pt", "np", "pil"]:
              raise ValueError(F"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"				)

          if output_type in ["np", "pil"]:
              __UpperCamelCase  		=						image * 0.5 + 0.5
              __UpperCamelCase  		=						image.clamp(0 ,       1				)
              __UpperCamelCase  		=						image.cpu().permute(0 ,       2 ,       3 ,       1				).float().numpy()

          if output_type == "pil":
              __UpperCamelCase  		=						self.numpy_to_pil(snake_case				)

          if not return_dict:
              return (image,)

          return ImagePipelineOutput(images=snake_case				)












import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np
import torch

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


a_   		=     logging.get_logger(__name__)

class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      lowerCAmelCase__			: Dict    =					["input_features", "is_longer"]







      def __init__(     self					: Dict ,       snake_case					: int=64 ,       snake_case					: Dict=48000 ,       snake_case					: Tuple=480 ,       snake_case					: Optional[Any]=10 ,       snake_case					: Union[str, Any]=1024 ,       snake_case					: Union[str, Any]=0.0 ,       snake_case					: List[str]=False ,       snake_case					: float = 0 ,       snake_case					: float = 14000 ,       snake_case					: int = None ,       snake_case					: str = "fusion" ,       snake_case					: str = "repeatpad" ,       **snake_case					: int ,       ):
          super().__init__(
              feature_size=snake_case ,       sampling_rate=snake_case ,       padding_value=snake_case ,       return_attention_mask=snake_case ,       **snake_case ,       )
          __UpperCamelCase  		=						top_db
          __UpperCamelCase  		=						truncation
          __UpperCamelCase  		=						padding
          __UpperCamelCase  		=						fft_window_size
          __UpperCamelCase  		=						(fft_window_size >> 1) + 1
          __UpperCamelCase  		=						hop_length
          __UpperCamelCase  		=						max_length_s
          __UpperCamelCase  		=						max_length_s * sampling_rate
          __UpperCamelCase  		=						sampling_rate
          __UpperCamelCase  		=						frequency_min
          __UpperCamelCase  		=						frequency_max
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm=snake_case ,       mel_scale='''htk''' ,       )
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm='''slaney''' ,       mel_scale='''slaney''' ,       )







      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						copy.deepcopy(self.__dict__				)
          __UpperCamelCase  		=						self.__class__.__name__
          if "mel_filters" in output:
              del output["mel_filters"]
          if "mel_filters_slaney" in output:
              del output["mel_filters_slaney"]
          return output







      def       snake_case	(     self					: Tuple ,       snake_case					: np.array ,       snake_case					: Optional[np.array] = None				):
          __UpperCamelCase  		=						spectrogram(
              snake_case ,       window_function(self.fft_window_size ,       '''hann'''				) ,       frame_length=self.fft_window_size ,       hop_length=self.hop_length ,       power=2.0 ,       mel_filters=snake_case ,       log_mel='''dB''' ,       )
          return log_mel_spectrogram.T







      def       snake_case	(     self					: Optional[int] ,       snake_case					: Any ,       snake_case					: List[Any] ,       snake_case					: int				):
          __UpperCamelCase  		=						np.array_split(list(range(0 ,       total_frames - chunk_frames + 1				)				) ,       3				)
          if len(ranges[1]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          if len(ranges[2]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          # randomly choose index for each part
          __UpperCamelCase  		=						np.random.choice(ranges[0]				)
          __UpperCamelCase  		=						np.random.choice(ranges[1]				)
          __UpperCamelCase  		=						np.random.choice(ranges[2]				)

          __UpperCamelCase  		=						mel[idx_front : idx_front + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_middle : idx_middle + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_back : idx_back + chunk_frames, :]

          __UpperCamelCase  		=						torch.tensor(mel[None, None, :]				)
          __UpperCamelCase  		=						torch.nn.functional.interpolate(
              snake_case ,       size=[chunk_frames, 64] ,       mode='''bilinear''' ,       align_corners=snake_case				)
          __UpperCamelCase  		=						mel_shrink[0][0].numpy()
          __UpperCamelCase  		=						np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,       axis=0				)
          return mel_fusion







      def       snake_case	(     self					: Optional[Any] ,       snake_case					: np.array ,       snake_case					: Optional[int] ,       snake_case					: Tuple ,       snake_case					: str				):
          if waveform.shape[0] > max_length:
              if truncation == "rand_trunc":
                  __UpperCamelCase  		=						True
                  # random crop to max_length (for compatibility) -> this should be handled by self.pad
                  __UpperCamelCase  		=						len(snake_case				) - max_length
                  __UpperCamelCase  		=						np.random.randint(0 ,       overflow + 1				)
                  __UpperCamelCase  		=						waveform[idx : idx + max_length]
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]
              elif truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
                  __UpperCamelCase  		=						mel.shape[0]
                  if chunk_frames == total_frames:
                      # there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
                      # In this case, we just use the whole audio.
                      __UpperCamelCase  		=						np.stack([mel, mel, mel, mel] ,       axis=0				)
                      __UpperCamelCase  		=						False
                  else:
                      __UpperCamelCase  		=						self._random_mel_fusion(snake_case ,       snake_case ,       snake_case				)
                      __UpperCamelCase  		=						True
              else:
                  raise NotImplementedError(F"data_truncating {truncation} not implemented"				)

          else:
              __UpperCamelCase  		=						False
              # only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
              if waveform.shape[0] < max_length:
                  if padding == "repeat":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       n_repeat + 1				)				)[:max_length]
                  if padding == "repeatpad":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       snake_case				)				)
                  __UpperCamelCase  		=						np.pad(snake_case ,       (0, max_length - waveform.shape[0]) ,       mode='''constant''' ,       constant_values=0				)

              if truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						np.stack([input_mel, input_mel, input_mel, input_mel] ,       axis=0				)
              else:
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]

          return input_mel, longer







      def __call__(     self					: List[str] ,       snake_case					: Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,       snake_case					: str = None ,       snake_case					: Optional[str] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[Union[str, TensorType]] = None ,       **snake_case					: Any ,       ):
          __UpperCamelCase  		=						truncation if truncation is not None else self.truncation
          __UpperCamelCase  		=						padding if padding else self.padding

          if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                  raise ValueError(
                      F"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
                      F" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
                      F" was sampled with {self.sampling_rate} and not {sampling_rate}."				)
          else:
              logger.warning(
                  '''It is strongly recommended to pass the `sampling_rate` argument to this function. '''
                  '''Failing to do so can result in silent errors that might be hard to debug.'''				)

          __UpperCamelCase  		=						isinstance(snake_case ,       np.ndarray				) and len(raw_speech.shape				) > 1
          if is_batched_numpy and len(raw_speech.shape				) > 2:
              raise ValueError(F"Only mono-channel audio is supported for input to {self}"				)
          __UpperCamelCase  		=						is_batched_numpy or (
              isinstance(snake_case ,       (list, tuple)				) and (isinstance(raw_speech[0] ,       (np.ndarray, tuple, list)				))
          )

          if is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for speech in raw_speech]
          elif not is_batched and not isinstance(snake_case ,       np.ndarray				):
              __UpperCamelCase  		=						np.asarray(snake_case ,       dtype=np.floataa				)
          elif isinstance(snake_case ,       np.ndarray				) and raw_speech.dtype is np.dtype(np.floataa				):
              __UpperCamelCase  		=						raw_speech.astype(np.floataa				)

          # always return batch
          if not is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case				)]

          # convert to mel spectrogram, truncate and pad if needed.
          __UpperCamelCase  		=						[
              self._get_input_mel(snake_case ,       max_length if max_length else self.nb_max_samples ,       snake_case ,       snake_case				)
              for waveform in raw_speech
          ]

          __UpperCamelCase  		=						[]
          __UpperCamelCase  		=						[]
          for mel, longer in padded_inputs:
              input_mel.append(snake_case				)
              is_longer.append(snake_case				)

          if truncation == "fusion" and sum(snake_case				) == 0:
              # if no audio is longer than 10s, then randomly select one audio to be longer
              __UpperCamelCase  		=						np.random.randint(0 ,       len(snake_case				)				)
              __UpperCamelCase  		=						True

          if isinstance(input_mel[0] ,       snake_case				):
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for feature in input_mel]

          # is_longer is a list of bool
          __UpperCamelCase  		=						[[longer] for longer in is_longer]

          __UpperCamelCase  		=						{'''input_features''': input_mel, '''is_longer''': is_longer}
          __UpperCamelCase  		=						BatchFeature(snake_case				)

          if return_tensors is not None:
              __UpperCamelCase  		=						input_features.convert_to_tensors(snake_case				)

          return input_features






