





'''simple docstring'''






from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

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,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
      import PIL

A__							:  Any    =logging.get_logger(__name__)
def   UpperCamelCase__ (						lowerCAmelCase    ):





      """simple docstring"""


      if isinstance(lowerCAmelCase				,      (list, tuple)    ) and isinstance(videos[0]				,      (list, tuple)    ) and is_valid_image(videos[0][0]    ):
            return videos

      elif isinstance(lowerCAmelCase				,      (list, tuple)    ) and is_valid_image(videos[0]    ):
            return [videos]

      elif is_valid_image(lowerCAmelCase    ):
            return [[videos]]

      raise ValueError(f"Could not make batched video from {videos}"    )





class 					UpperCAmelCase	(     snake_case_  ):
      _lowercase:     str			=  ['''pixel_values''']




      def __init__(     self     :					Any     ,     __snake_case     :					bool = True     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					PILImageResampling = PILImageResampling.BILINEAR     ,     __snake_case     :					bool = True     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					bool = True     ,     __snake_case     :					Union[int, float] = 1 / 2_55     ,     __snake_case     :					bool = True     ,     __snake_case     :					bool = True     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     **__snake_case     :					List[str]     ,     )							-> None:
            super().__init__(**__snake_case    )
            _lowerCAmelCase					=				size if size is not None else {"""shortest_edge""": 2_56}
            _lowerCAmelCase					=				get_size_dict(__snake_case     ,     default_to_square=__snake_case    )
            _lowerCAmelCase					=				crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
            _lowerCAmelCase					=				get_size_dict(__snake_case     ,     param_name="""crop_size"""    )

            _lowerCAmelCase					=				do_resize
            _lowerCAmelCase					=				size
            _lowerCAmelCase					=				do_center_crop
            _lowerCAmelCase					=				crop_size
            _lowerCAmelCase					=				resample
            _lowerCAmelCase					=				do_rescale
            _lowerCAmelCase					=				rescale_factor
            _lowerCAmelCase					=				offset
            _lowerCAmelCase					=				do_normalize
            _lowerCAmelCase					=				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
            _lowerCAmelCase					=				image_std if image_std is not None else IMAGENET_STANDARD_STD




      def 							lowercase__       (     self     :					List[Any]     ,     __snake_case     :					np.ndarray     ,     __snake_case     :					Dict[str, int]     ,     __snake_case     :					PILImageResampling = PILImageResampling.BILINEAR     ,     __snake_case     :					Optional[Union[str, ChannelDimension]] = None     ,     **__snake_case     :					Dict     ,     )							-> np.ndarray:
            _lowerCAmelCase					=				get_size_dict(__snake_case     ,     default_to_square=__snake_case    )
            if "shortest_edge" in size:
                  _lowerCAmelCase					=				get_resize_output_image_size(__snake_case     ,     size["""shortest_edge"""]     ,     default_to_square=__snake_case    )
            elif "height" in size and "width" in size:
                  _lowerCAmelCase					=				(size["""height"""], size["""width"""])
            else:
                  raise ValueError(f"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"    )
            return resize(__snake_case     ,     size=__snake_case     ,     resample=__snake_case     ,     data_format=__snake_case     ,     **__snake_case    )




      def 							lowercase__       (     self     :					Union[str, Any]     ,     __snake_case     :					np.ndarray     ,     __snake_case     :					Dict[str, int]     ,     __snake_case     :					Optional[Union[str, ChannelDimension]] = None     ,     **__snake_case     :					List[Any]     ,     )							-> np.ndarray:
            _lowerCAmelCase					=				get_size_dict(__snake_case    )
            if "height" not in size or "width" not in size:
                  raise ValueError(f"Size must have 'height' and 'width' as keys. Got {size.keys()}"    )
            return center_crop(__snake_case     ,     size=(size["""height"""], size["""width"""])     ,     data_format=__snake_case     ,     **__snake_case    )




      def 							lowercase__       (     self     :					List[str]     ,     __snake_case     :					np.ndarray     ,     __snake_case     :					Union[int, float]     ,     __snake_case     :					bool = True     ,     __snake_case     :					Optional[Union[str, ChannelDimension]] = None     ,     **__snake_case     :					Any     ,     )							-> Any:
            _lowerCAmelCase					=				image.astype(np.floataa    )
            if offset:
                  _lowerCAmelCase					=				image - (scale / 2)
            return rescale(__snake_case     ,     scale=__snake_case     ,     data_format=__snake_case     ,     **__snake_case    )




      def 							lowercase__       (     self     :					Any     ,     __snake_case     :					np.ndarray     ,     __snake_case     :					Union[float, List[float]]     ,     __snake_case     :					Union[float, List[float]]     ,     __snake_case     :					Optional[Union[str, ChannelDimension]] = None     ,     **__snake_case     :					Dict     ,     )							-> np.ndarray:
            return normalize(__snake_case     ,     mean=__snake_case     ,     std=__snake_case     ,     data_format=__snake_case     ,     **__snake_case    )




      def 							lowercase__       (     self     :					Optional[Any]     ,     __snake_case     :					ImageInput     ,     __snake_case     :					bool = None     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					PILImageResampling = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					float = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     __snake_case     :					Optional[ChannelDimension] = ChannelDimension.FIRST     ,     )							-> np.ndarray:
            if do_resize and size is None or resample is None:
                  raise ValueError("""Size and resample 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."""    )

            if offset and not do_rescale:
                  raise ValueError("""For offset, do_rescale must also be set to True."""    )

            # All transformations expect numpy arrays.
            _lowerCAmelCase					=				to_numpy_array(__snake_case    )

            if do_resize:
                  _lowerCAmelCase					=				self.resize(image=__snake_case     ,     size=__snake_case     ,     resample=__snake_case    )

            if do_center_crop:
                  _lowerCAmelCase					=				self.center_crop(__snake_case     ,     size=__snake_case    )

            if do_rescale:
                  _lowerCAmelCase					=				self.rescale(image=__snake_case     ,     scale=__snake_case     ,     offset=__snake_case    )

            if do_normalize:
                  _lowerCAmelCase					=				self.normalize(image=__snake_case     ,     mean=__snake_case     ,     std=__snake_case    )

            _lowerCAmelCase					=				to_channel_dimension_format(__snake_case     ,     __snake_case    )
            return image




      def 							lowercase__       (     self     :					Union[str, Any]     ,     __snake_case     :					ImageInput     ,     __snake_case     :					bool = None     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					PILImageResampling = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					Dict[str, int] = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					float = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					bool = None     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     __snake_case     :					Optional[Union[float, List[float]]] = None     ,     __snake_case     :					Optional[Union[str, TensorType]] = None     ,     __snake_case     :					ChannelDimension = ChannelDimension.FIRST     ,     **__snake_case     :					str     ,     )							-> PIL.Image.Image:
            _lowerCAmelCase					=				do_resize if do_resize is not None else self.do_resize
            _lowerCAmelCase					=				resample if resample is not None else self.resample
            _lowerCAmelCase					=				do_center_crop if do_center_crop is not None else self.do_center_crop
            _lowerCAmelCase					=				do_rescale if do_rescale is not None else self.do_rescale
            _lowerCAmelCase					=				rescale_factor if rescale_factor is not None else self.rescale_factor
            _lowerCAmelCase					=				offset if offset is not None else self.offset
            _lowerCAmelCase					=				do_normalize if do_normalize is not None else self.do_normalize
            _lowerCAmelCase					=				image_mean if image_mean is not None else self.image_mean
            _lowerCAmelCase					=				image_std if image_std is not None else self.image_std

            _lowerCAmelCase					=				size if size is not None else self.size
            _lowerCAmelCase					=				get_size_dict(__snake_case     ,     default_to_square=__snake_case    )
            _lowerCAmelCase					=				crop_size if crop_size is not None else self.crop_size
            _lowerCAmelCase					=				get_size_dict(__snake_case     ,     param_name="""crop_size"""    )

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

            _lowerCAmelCase					=				make_batched(__snake_case    )

            _lowerCAmelCase					=				[
                [
                    self._preprocess_image(
                        image=__snake_case     ,     do_resize=__snake_case     ,     size=__snake_case     ,     resample=__snake_case     ,     do_center_crop=__snake_case     ,     crop_size=__snake_case     ,     do_rescale=__snake_case     ,     rescale_factor=__snake_case     ,     offset=__snake_case     ,     do_normalize=__snake_case     ,     image_mean=__snake_case     ,     image_std=__snake_case     ,     data_format=__snake_case     ,     )
                    for img in video
                ]
                for video in videos
            ]

            _lowerCAmelCase					=				{"""pixel_values""": videos}
            return BatchFeature(data=__snake_case     ,     tensor_type=__snake_case    )













'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


A__							:  int    ={
    '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''],
    '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''],
    '''processing_wav2vec2''': ['''Wav2Vec2Processor'''],
    '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''],
}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__							:  str    =[
          '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''Wav2Vec2ForAudioFrameClassification''',
          '''Wav2Vec2ForCTC''',
          '''Wav2Vec2ForMaskedLM''',
          '''Wav2Vec2ForPreTraining''',
          '''Wav2Vec2ForSequenceClassification''',
          '''Wav2Vec2ForXVector''',
          '''Wav2Vec2Model''',
          '''Wav2Vec2PreTrainedModel''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__							:  Union[str, Any]    =[
          '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFWav2Vec2ForCTC''',
          '''TFWav2Vec2Model''',
          '''TFWav2Vec2PreTrainedModel''',
          '''TFWav2Vec2ForSequenceClassification''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__							:  List[str]    =[
          '''FlaxWav2Vec2ForCTC''',
          '''FlaxWav2Vec2ForPreTraining''',
          '''FlaxWav2Vec2Model''',
          '''FlaxWav2Vec2PreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
      from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
      from .processing_wavaveca import WavaVecaProcessor
      from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_wavaveca import (
                WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
                WavaVecaForAudioFrameClassification,
                WavaVecaForCTC,
                WavaVecaForMaskedLM,
                WavaVecaForPreTraining,
                WavaVecaForSequenceClassification,
                WavaVecaForXVector,
                WavaVecaModel,
                WavaVecaPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_wavaveca import (
                TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFWavaVecaForCTC,
                TFWavaVecaForSequenceClassification,
                TFWavaVecaModel,
                TFWavaVecaPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_wavaveca import (
                FlaxWavaVecaForCTC,
                FlaxWavaVecaForPreTraining,
                FlaxWavaVecaModel,
                FlaxWavaVecaPreTrainedModel,
            )


else:
      import sys

      A__							:  Any    =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






