


from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


_A		       =						logging.get_logger(__name__)






class     UpperCAmelCase__       (					A_		):



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_					,   **A_    )  ->       Optional[Any]:
         __UpperCamelCase    							=feature_size
         __UpperCamelCase    							=sampling_rate
         __UpperCamelCase    							=padding_value

         __UpperCamelCase    							=kwargs.pop('padding_side'					,   'right'    )
         __UpperCamelCase    							=kwargs.pop('return_attention_mask'					,   A_    )

         super().__init__(**A_    )






    def _a					(			self					,   A_					,   A_ = True					,   A_ = None					,   A_ = False					,   A_ = None					,   A_ = None					,   A_ = None					,   )  ->       BatchFeature:
         # If we have a list of dicts, let's convert it in a dict of lists
         # We do this to allow using this method as a collate_fn function in PyTorch Dataloader
         if isinstance(A_					,   (list, tuple)    ) and isinstance(processed_features[0]					,   (dict, BatchFeature)    ):
              __UpperCamelCase    							={
                  key: [example[key] for example in processed_features] for key in processed_features[0].keys()
              }

         # The model's main input name, usually `input_values`, has be passed for padding
         if self.model_input_names[0] not in processed_features:
              raise ValueError(
                  'You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`'
                  f' to this method that includes {self.model_input_names[0]}, but you provided'
                  f' {list(processed_features.keys()    )}'    )

         __UpperCamelCase    							=processed_features[self.model_input_names[0]]
         __UpperCamelCase    							=(
             return_attention_mask if return_attention_mask is not None else self.return_attention_mask
         )

         if len(A_    ) == 0:
              if return_attention_mask:
                   __UpperCamelCase    							=[]
              return processed_features

         # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
         # and rebuild them afterwards if no return_tensors is specified
         # Note that we lose the specific device the tensor may be on for PyTorch

         __UpperCamelCase    							=required_input[0]
         if isinstance(A_					,   (list, tuple)    ):
              # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
              __UpperCamelCase    							=0
              while len(required_input[index]    ) == 0:
                   index += 1
              if index < len(A_    ):
                   __UpperCamelCase    							=required_input[index][0]

         if return_tensors is None:
              if is_tf_tensor(A_    ):
                   __UpperCamelCase    							='tf'
              elif is_torch_tensor(A_    ):
                   __UpperCamelCase    							='pt'
              elif isinstance(A_					,   (int, float, list, tuple, np.ndarray)    ):
                   __UpperCamelCase    							='np'
              else:
                   raise ValueError(
                       f'type of {first_element} unknown: {type(A_    )}. '
                       'Should be one of a python, numpy, pytorch or tensorflow object.'    )

         for key, value in processed_features.items():
              if isinstance(value[0]					,   (int, float)    ):
                   __UpperCamelCase    							=to_numpy(A_    )
              else:
                   __UpperCamelCase    							=[to_numpy(A_    ) for v in value]

        # Convert padding_strategy in PaddingStrategy
         __UpperCamelCase    							=self._get_padding_strategies(padding=A_					,   max_length=A_    )

         __UpperCamelCase    							=processed_features[self.model_input_names[0]]

         __UpperCamelCase    							=len(A_    )
         if not all(len(A_    ) == batch_size for v in processed_features.values()    ):
              raise ValueError('Some items in the output dictionary have a different batch size than others.'    )

         __UpperCamelCase    							=[]
         for i in range(A_    ):
              __UpperCamelCase    							={k: v[i] for k, v in processed_features.items()}
              # truncation
              __UpperCamelCase    							=self._truncate(
                  A_					,   max_length=A_					,   pad_to_multiple_of=A_					,   truncation=A_					,   )
              truncated_inputs.append(A_    )

         if padding_strategy == PaddingStrategy.LONGEST:
              # make sure that `max_length` cannot be longer than the longest truncated length
              __UpperCamelCase    							=max(len(input_slice[self.model_input_names[0]]    ) for input_slice in truncated_inputs    )
              __UpperCamelCase    							=PaddingStrategy.MAX_LENGTH

         __UpperCamelCase    							={}
         for i in range(A_    ):
              # padding
              __UpperCamelCase    							=self._pad(
                  truncated_inputs[i]					,   max_length=A_					,   padding_strategy=A_					,   pad_to_multiple_of=A_					,   return_attention_mask=A_					,   )

              for key, value in outputs.items():
                   if key not in batch_outputs:
                        __UpperCamelCase    							=[]
                   if value.dtype is np.dtype(np.floataa    ):
                        __UpperCamelCase    							=value.astype(np.floataa    )
                   batch_outputs[key].append(A_    )

         return BatchFeature(A_					,   tensor_type=A_    )






    def _a					(			self					,   A_					,   A_ = None					,   A_ = PaddingStrategy.DO_NOT_PAD					,   A_ = None					,   A_ = None					,   )  ->       dict:
         __UpperCamelCase    							=processed_features[self.model_input_names[0]]

         if padding_strategy == PaddingStrategy.LONGEST:
              __UpperCamelCase    							=len(A_    )

         if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
              __UpperCamelCase    							=((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

         __UpperCamelCase    							=padding_strategy != PaddingStrategy.DO_NOT_PAD and len(A_    ) < max_length

         if return_attention_mask and "attention_mask" not in processed_features:
              __UpperCamelCase    							=np.ones(len(A_    )					,   dtype=np.intaa    )

         if needs_to_be_padded:
              __UpperCamelCase    							=max_length - len(A_    )
              if self.padding_side == "right":
                   if return_attention_mask:
                        __UpperCamelCase    							=np.pad(
                            processed_features['attention_mask']					,   (0, difference)    )
                   __UpperCamelCase    							=((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
                   __UpperCamelCase    							=np.pad(
                       A_					,   A_					,   'constant'					,   constant_values=self.padding_value    )
              elif self.padding_side == "left":
                   if return_attention_mask:
                        __UpperCamelCase    							=np.pad(
                            processed_features['attention_mask']					,   (difference, 0)    )
                   __UpperCamelCase    							=((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
                   __UpperCamelCase    							=np.pad(
                       A_					,   A_					,   'constant'					,   constant_values=self.padding_value    )
              else:
                   raise ValueError('Invalid padding strategy:' + str(self.padding_side    )    )

         return processed_features






    def _a					(			self					,   A_					,   A_ = None					,   A_ = None					,   A_ = None					,   )  ->       Optional[Any]:
         if not truncation:
              return processed_features
         elif truncation and max_length is None:
              raise ValueError('When setting ``truncation=True``, make sure that ``max_length`` is defined.'    )

         __UpperCamelCase    							=processed_features[self.model_input_names[0]]

         # find `max_length` that fits `pad_to_multiple_of`
         if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
              __UpperCamelCase    							=((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

         __UpperCamelCase    							=len(A_    ) > max_length

         if needs_to_be_truncated:
              __UpperCamelCase    							=processed_features[self.model_input_names[0]][:max_length]
              if "attention_mask" in processed_features:
                   __UpperCamelCase    							=processed_features['attention_mask'][:max_length]

         return processed_features






    def _a					(			self					,   A_=False					,   A_=None    )  ->       Optional[int]:

         # Get padding strategy
         if padding is not False:
              if padding is True:
                   __UpperCamelCase    							=PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
              elif not isinstance(A_					,   A_    ):
                   __UpperCamelCase    							=PaddingStrategy(A_    )
              elif isinstance(A_					,   A_    ):
                   __UpperCamelCase    							=padding
         else:
              __UpperCamelCase    							=PaddingStrategy.DO_NOT_PAD

         # Set max length if needed
         if max_length is None:
              if padding_strategy == PaddingStrategy.MAX_LENGTH:
                   raise ValueError(
                       f'When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined'    )

        # Test if we have a padding value
         if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
              raise ValueError(
                  'Asking to pad but the feature_extractor does not have a padding value. Please select a value to use'
                  ' as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.'    )

         return padding_strategy









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_A		       =						{
    'configuration_vivit': ['VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VivitConfig'],
}
try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A		       =						['VivitImageProcessor']


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A		       =						[
       'VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'VivitModel',
       'VivitPreTrainedModel',
       'VivitForVideoClassification',
   ]


if TYPE_CHECKING:
   from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_vivit import VivitImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vivit import (
          VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
          VivitForVideoClassification,
          VivitModel,
          VivitPreTrainedModel,
      )


else:
   import sys

   _A		       =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





