

'''simple docstring'''




from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
      import torch


_lowerCAmelCase         =						logging.get_logger(__name__)






class   _SCREAMING_SNAKE_CASE   (   __a     ):
 __SCREAMING_SNAKE_CASE					:Optional[Any]      	=					["""pixel_values"""]



 def __init__(   self		:   Tuple			,				a__		:   bool = True			,				a__		:   Optional[Dict[str, int]] = None			,				a__		:   PILImageResampling = PILImageResampling.BILINEAR			,				a__		:   bool = True			,				a__		:   Dict[str, int] = None			,				a__		:   bool = True			,				a__		:   Union[int, float] = 1 / 255			,				a__		:   bool = True			,				a__		:   Optional[Union[float, List[float]]] = None			,				a__		:   Optional[Union[float, List[float]]] = None			,				**a__		:   Any			,				):
      super().__init__(**a__      )
      __magic_name__						       =    size if size is not None else {'''shortest_edge''': 256}
      __magic_name__						       =    get_size_dict(a__			,				default_to_square=a__      )
      __magic_name__						       =    crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
      __magic_name__						       =    get_size_dict(a__			,				param_name='''crop_size'''      )
      __magic_name__						       =    do_resize
      __magic_name__						       =    size
      __magic_name__						       =    resample
      __magic_name__						       =    do_center_crop
      __magic_name__						       =    crop_size
      __magic_name__						       =    do_rescale
      __magic_name__						       =    rescale_factor
      __magic_name__						       =    do_normalize
      __magic_name__						       =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      __magic_name__						       =    image_std if image_std is not None else IMAGENET_STANDARD_STD



 def 			snake_case__  (   self		:   List[Any]			,				a__		:   np.ndarray			,				a__		:   Dict[str, int]			,				a__		:   PILImageResampling = PILImageResampling.BICUBIC			,				a__		:   Optional[Union[str, ChannelDimension]] = None			,				**a__		:   Dict			,				):
      __magic_name__						       =    get_size_dict(a__			,				default_to_square=a__      )
      if "shortest_edge" not in size:
           raise ValueError(F'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''      )
      __magic_name__						       =    get_resize_output_image_size(a__			,				size=size['''shortest_edge''']			,				default_to_square=a__      )
      return resize(a__			,				size=a__			,				resample=a__			,				data_format=a__			,				**a__      )



 def 			snake_case__  (   self		:   int			,				a__		:   np.ndarray			,				a__		:   Dict[str, int]			,				a__		:   Optional[Union[str, ChannelDimension]] = None			,				**a__		:   Union[str, Any]			,				):
      __magic_name__						       =    get_size_dict(a__      )
      if "height" not in size or "width" not in size:
           raise ValueError(F'''The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}'''      )
      return center_crop(a__			,				size=(size['''height'''], size['''width'''])			,				data_format=a__			,				**a__      )



 def 			snake_case__  (   self		:   Any			,				a__		:   np.ndarray			,				a__		:   float			,				a__		:   Optional[Union[str, ChannelDimension]] = None			,				**a__		:   List[str]      ):
      return rescale(a__			,				scale=a__			,				data_format=a__			,				**a__      )



 def 			snake_case__  (   self		:   List[Any]			,				a__		:   np.ndarray			,				a__		:   Union[float, List[float]]			,				a__		:   Union[float, List[float]]			,				a__		:   Optional[Union[str, ChannelDimension]] = None			,				**a__		:   Optional[Any]			,				):
      return normalize(a__			,				mean=a__			,				std=a__			,				data_format=a__			,				**a__      )



 def 			snake_case__  (   self		:   str			,				a__		:   ImageInput			,				a__		:   Optional[bool] = None			,				a__		:   Dict[str, int] = None			,				a__		:   PILImageResampling = None			,				a__		:   bool = None			,				a__		:   Dict[str, int] = None			,				a__		:   Optional[bool] = None			,				a__		:   Optional[float] = None			,				a__		:   Optional[bool] = None			,				a__		:   Optional[Union[float, List[float]]] = None			,				a__		:   Optional[Union[float, List[float]]] = None			,				a__		:   Optional[Union[str, TensorType]] = None			,				a__		:   Union[str, ChannelDimension] = ChannelDimension.FIRST			,				**a__		:   Union[str, Any]			,				):
      __magic_name__						       =    do_resize if do_resize is not None else self.do_resize
      __magic_name__						       =    size if size is not None else self.size
      __magic_name__						       =    get_size_dict(a__			,				default_to_square=a__      )
      __magic_name__						       =    resample if resample is not None else self.resample
      __magic_name__						       =    do_center_crop if do_center_crop is not None else self.do_center_crop
      __magic_name__						       =    crop_size if crop_size is not None else self.crop_size
      __magic_name__						       =    get_size_dict(a__			,				param_name='''crop_size'''      )
      __magic_name__						       =    do_rescale if do_rescale is not None else self.do_rescale
      __magic_name__						       =    rescale_factor if rescale_factor is not None else self.rescale_factor
      __magic_name__						       =    do_normalize if do_normalize is not None else self.do_normalize
      __magic_name__						       =    image_mean if image_mean is not None else self.image_mean
      __magic_name__						       =    image_std if image_std is not None else self.image_std

      __magic_name__						       =    make_list_of_images(a__      )

      if not valid_images(a__      ):
           raise ValueError(
               '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
               '''torch.Tensor, tf.Tensor or jax.ndarray.'''      )

      if do_resize and size is None:
           raise ValueError('''Size must be specified if do_resize is True.'''      )

      if do_center_crop and crop_size is None:
           raise ValueError('''Crop size must be specified if do_center_crop is True.'''      )

      if do_rescale and rescale_factor is None:
           raise ValueError('''Rescale factor must be specified if do_rescale is True.'''      )

      if do_normalize and (image_mean is None or image_std is None):
           raise ValueError('''Image mean and std must be specified if do_normalize is True.'''      )

      # All transformations expect numpy arrays.
      __magic_name__						       =    [to_numpy_array(a__      ) for image in images]

      if do_resize:
           __magic_name__						       =    [self.resize(image=a__			,				size=a__			,				resample=a__      ) for image in images]

      if do_center_crop:
           __magic_name__						       =    [self.center_crop(image=a__			,				size=a__      ) for image in images]

      if do_rescale:
           __magic_name__						       =    [self.rescale(image=a__			,				scale=a__      ) for image in images]

      if do_normalize:
           __magic_name__						       =    [self.normalize(image=a__			,				mean=a__			,				std=a__      ) for image in images]

      __magic_name__						       =    [to_channel_dimension_format(a__			,				a__      ) for image in images]

      __magic_name__						       =    {'''pixel_values''': images}
      return BatchFeature(data=a__			,				tensor_type=a__      )



 def 			snake_case__  (   self		:   Tuple			,				a__		:   Any			,				a__		:   List[Tuple] = None      ):
      __magic_name__						       =    outputs.logits

      # Resize logits and compute semantic segmentation maps
      if target_sizes is not None:
           if len(a__      ) != len(a__      ):
                raise ValueError(
                    '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''      )

           if is_torch_tensor(a__      ):
                __magic_name__						       =    target_sizes.numpy()

           __magic_name__						       =    []

           for idx in range(len(a__      )      ):
                __magic_name__						       =    torch.nn.functional.interpolate(
                    logits[idx].unsqueeze(dim=0      )			,				size=target_sizes[idx]			,				mode='''bilinear'''			,				align_corners=a__      )
                __magic_name__						       =    resized_logits[0].argmax(dim=0      )
                semantic_segmentation.append(a__      )
      else:
           __magic_name__						       =    logits.argmax(dim=1      )
           __magic_name__						       =    [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]      )]

      return semantic_segmentation









'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCAmelCase         =						{
    "configuration_clap": [
        "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
        "ClapAudioConfig",
        "ClapConfig",
        "ClapTextConfig",
    ],
    "processing_clap": ["ClapProcessor"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCAmelCase         =						[
          "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
          "ClapModel",
          "ClapPreTrainedModel",
          "ClapTextModel",
          "ClapTextModelWithProjection",
          "ClapAudioModel",
          "ClapAudioModelWithProjection",
      ]
      _lowerCAmelCase         =						["ClapFeatureExtractor"]

if TYPE_CHECKING:
      from .configuration_clap import (
          CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
          ClapAudioConfig,
          ClapConfig,
          ClapTextConfig,
      )
      from .processing_clap import ClapProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_clap import ClapFeatureExtractor
            from .modeling_clap import (
                CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
                ClapAudioModel,
                ClapAudioModelWithProjection,
                ClapModel,
                ClapPreTrainedModel,
                ClapTextModel,
                ClapTextModelWithProjection,
            )


else:
      import sys

      _lowerCAmelCase         =						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






