





from __future__ import annotations

from collections import deque




class        _a    :

      """simple docstring"""


      def __init__(		self:			Dict	,    __lowerCamelCase:			list[str]					):
          '''simple docstring'''


          UpperCamelCase__:	list[dict]					=     []
          self.adlist.append(
              {"value": "", "next_states": [], "fail_state": 0, "output": []}					)

          for keyword in keywords:
              self.add_keyword(__lowerCamelCase					)
          self.set_fail_transitions()






      def 			UpperCAmelCase_       (		self:			Optional[Any]	,    __lowerCamelCase:			int	,    __lowerCamelCase:			str					):
          '''simple docstring'''


          for state in self.adlist[current_state]["next_states"]:
              if char == self.adlist[state]["value"]:
                  return state
          return None






      def 			UpperCAmelCase_       (		self:			str	,    __lowerCamelCase:			str					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     0
          for character in keyword:
              UpperCamelCase__:	Dict					=     self.find_next_state(__lowerCamelCase	,    __lowerCamelCase					)
              if next_state is None:
                  self.adlist.append(
                      {
                          "value": character,
                          "next_states": [],
                          "fail_state": 0,
                          "output": [],
                      }					)
                  self.adlist[current_state]["next_states"].append(len(self.adlist					) - 1					)
                  UpperCamelCase__:	Optional[Any]					=     len(self.adlist					) - 1
              else:
                  UpperCamelCase__:	int					=     next_state
          self.adlist[current_state]["output"].append(__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          UpperCamelCase__:	deque					=     deque()
          for node in self.adlist[0]["next_states"]:
              q.append(__lowerCamelCase					)
              UpperCamelCase__:	Tuple					=     0
          while q:
              UpperCamelCase__:	int					=     q.popleft()
              for child in self.adlist[r]["next_states"]:
                  q.append(__lowerCamelCase					)
                  UpperCamelCase__:	Union[str, Any]					=     self.adlist[r]["fail_state"]
                  while (
                      self.find_next_state(__lowerCamelCase	,    self.adlist[child]["value"]					) is None
                      and state != 0
                  ):
                      UpperCamelCase__:	Tuple					=     self.adlist[state]["fail_state"]
                  UpperCamelCase__:	Union[str, Any]					=     self.find_next_state(
                      __lowerCamelCase	,    self.adlist[child]["value"]					)
                  if self.adlist[child]["fail_state"] is None:
                      UpperCamelCase__:	Dict					=     0
                  UpperCamelCase__:	Optional[int]					=     (
                      self.adlist[child]["output"]
                      + self.adlist[self.adlist[child]["fail_state"]]["output"]
                  )






      def 			UpperCAmelCase_       (		self:			int	,    __lowerCamelCase:			str					):
          '''simple docstring'''


          UpperCamelCase__:	dict					=     {}  # returns a dict with keywords and list of its occurrences
          UpperCamelCase__:	List[Any]					=     0
          for i in range(len(__lowerCamelCase					)					):
              while (
                  self.find_next_state(__lowerCamelCase	,    string[i]					) is None
                  and current_state != 0
              ):
                  UpperCamelCase__:	List[str]					=     self.adlist[current_state]["fail_state"]
              UpperCamelCase__:	int					=     self.find_next_state(__lowerCamelCase	,    string[i]					)
              if next_state is None:
                  UpperCamelCase__:	Any					=     0
              else:
                  UpperCamelCase__:	Optional[int]					=     next_state
                  for key in self.adlist[current_state]["output"]:
                      if key not in result:
                          UpperCamelCase__:	Tuple					=     []
                      result[key].append(i - len(__lowerCamelCase					) + 1					)
          return result


if __name__ == "__main__":
   import doctest

   doctest.testmod()








import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin




class        _a    (    UpperCamelCase__):

      """simple docstring"""


      UpperCamelCase__  		=       None
      UpperCamelCase__  		=       None






      @property
      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          return self.feat_extract_tester.prepare_feat_extract_dict()






      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     self.feature_extraction_class(**self.feat_extract_dict					)
          self.assertTrue(hasattr(__lowerCamelCase	,    "feature_size"					)					)
          self.assertTrue(hasattr(__lowerCamelCase	,    "sampling_rate"					)					)
          self.assertTrue(hasattr(__lowerCamelCase	,    "padding_value"					)					)






      def 			UpperCAmelCase_       (		self:			Dict					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[int]					=     self.feat_extract_tester.prepare_inputs_for_common()
          UpperCamelCase__:	List[Any]					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	str					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Optional[int]					=     BatchFeature({input_name: speech_inputs}					)

          self.assertTrue(all(len(__lowerCamelCase					) == len(__lowerCamelCase					) for x, y in zip(__lowerCamelCase	,    processed_features[input_name]					)					)					)

          UpperCamelCase__:	Dict					=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase					)
          UpperCamelCase__:	Any					=     BatchFeature({input_name: speech_inputs}	,    tensor_type="np"					)

          UpperCamelCase__:	List[str]					=     processed_features[input_name]

          if len(batch_features_input.shape					) < 3:
              UpperCamelCase__:	str					=     batch_features_input[:, :, None]

          self.assertTrue(
              batch_features_input.shape
              == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






      @require_torch
      def 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          UpperCamelCase__:	Dict					=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase					)
          UpperCamelCase__:	Union[str, Any]					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	List[Any]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Optional[int]					=     BatchFeature({input_name: speech_inputs}	,    tensor_type="pt"					)

          UpperCamelCase__:	Dict					=     processed_features[input_name]

          if len(batch_features_input.shape					) < 3:
              UpperCamelCase__:	Tuple					=     batch_features_input[:, :, None]

          self.assertTrue(
              batch_features_input.shape
              == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






      @require_tf
      def 			UpperCAmelCase_       (		self:			Optional[Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase					)
          UpperCamelCase__:	Tuple					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	List[str]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Dict					=     BatchFeature({input_name: speech_inputs}	,    tensor_type="tf"					)

          UpperCamelCase__:	int					=     processed_features[input_name]

          if len(batch_features_input.shape					) < 3:
              UpperCamelCase__:	int					=     batch_features_input[:, :, None]

          self.assertTrue(
              batch_features_input.shape
              == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






      def 			UpperCAmelCase_       (		self:			List[Any]	,    __lowerCamelCase:			int=False					):
          '''simple docstring'''


          def _inputs_have_equal_length(__lowerCamelCase:			Optional[int]					):
              UpperCamelCase__:	Optional[int]					=     len(input[0]					)
              for input_slice in input[1:]:
                  if len(__lowerCamelCase					) != length:
                      return False
              return True

          def _inputs_are_equal(__lowerCamelCase:			List[str]	,    __lowerCamelCase:			str					):
              if len(__lowerCamelCase					) != len(__lowerCamelCase					):
                  return False

              for input_slice_a, input_slice_a in zip(__lowerCamelCase	,    __lowerCamelCase					):
                  if not np.allclose(np.asarray(__lowerCamelCase					)	,    np.asarray(__lowerCamelCase					)	,    atol=1e-3					):
                      return False
              return True

          UpperCamelCase__:	List[Any]					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	Optional[int]					=     self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCamelCase					)
          UpperCamelCase__:	Optional[int]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Dict					=     BatchFeature({input_name: speech_inputs}					)

          UpperCamelCase__:	Dict					=     self.feat_extract_tester.seq_length_diff
          UpperCamelCase__:	List[Any]					=     self.feat_extract_tester.max_seq_length + pad_diff
          UpperCamelCase__:	List[str]					=     self.feat_extract_tester.min_seq_length
          UpperCamelCase__:	str					=     self.feat_extract_tester.batch_size
          UpperCamelCase__:	Tuple					=     self.feat_extract_tester.feature_size

          # test padding for List[int] + numpy
          UpperCamelCase__:	int					=     feat_extract.pad(__lowerCamelCase	,    padding=__lowerCamelCase					)
          UpperCamelCase__:	List[str]					=     input_a[input_name]

          UpperCamelCase__:	Dict					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"					)
          UpperCamelCase__:	int					=     input_a[input_name]

          UpperCamelCase__:	int					=     feat_extract.pad(__lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[-1]					)					)
          UpperCamelCase__:	Union[str, Any]					=     input_a[input_name]

          UpperCamelCase__:	Any					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="np"					)
          UpperCamelCase__:	Dict					=     input_a[input_name]

          # max_length parameter has to be provided when setting `padding="max_length"`
          with self.assertRaises(__lowerCamelCase					):
              feat_extract.pad(__lowerCamelCase	,    padding="max_length"					)[input_name]

          UpperCamelCase__:	Optional[Any]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=__lowerCamelCase	,    return_tensors="np"					)
          UpperCamelCase__:	Tuple					=     input_a[input_name]

          self.assertFalse(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(_inputs_are_equal(__lowerCamelCase	,    __lowerCamelCase					)					)
          self.assertTrue(len(input_a[0]					) == pad_min_length					)
          self.assertTrue(len(input_a[1]					) == pad_min_length + pad_diff					)
          self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]					))					)
          self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)					)

          if feature_size > 1:
              self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size					)

          # test padding for `pad_to_multiple_of` for List[int] + numpy
          UpperCamelCase__:	int					=     feat_extract.pad(__lowerCamelCase	,    pad_to_multiple_of=10					)
          UpperCamelCase__:	List[str]					=     input_a[input_name]

          UpperCamelCase__:	Optional[int]					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    pad_to_multiple_of=10					)
          UpperCamelCase__:	int					=     input_a[input_name]

          UpperCamelCase__:	Tuple					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    pad_to_multiple_of=10	,    max_length=__lowerCamelCase					)
          UpperCamelCase__:	Tuple					=     input_a[input_name]

          UpperCamelCase__:	Optional[int]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    pad_to_multiple_of=10	,    max_length=__lowerCamelCase	,    return_tensors="np"	,    )
          UpperCamelCase__:	Any					=     input_a[input_name]

          self.assertTrue(all(len(__lowerCamelCase					) % 10 == 0 for x in input_a					)					)
          self.assertTrue(_inputs_are_equal(__lowerCamelCase	,    __lowerCamelCase					)					)

          UpperCamelCase__:	Dict					=     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
          self.assertTrue(all(len(__lowerCamelCase					) == expected_mult_pad_length for x in input_a					)					)
          self.assertEqual(input_a.shape[:2]	,    (batch_size, expected_mult_pad_length)					)

          if feature_size > 1:
              self.assertTrue(input_a.shape[2] == feature_size					)

          # Check padding value is correct
          UpperCamelCase__:	List[str]					=     (np.ones(self.feat_extract_tester.feature_size					) * feat_extract.padding_value).sum()
          self.assertTrue(
              abs(np.asarray(input_a[0]					)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					)
              < 1e-3					)
          self.assertTrue(
              abs(
                  np.asarray(input_a[1]					)[pad_min_length + pad_diff :].sum()
                  - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)					)
              < 1e-3					)
          self.assertTrue(
              abs(
                  np.asarray(input_a[2]					)[pad_min_length + 2 * pad_diff :].sum()
                  - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)					)
              < 1e-3					)
          self.assertTrue(
              abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					) < 1e-3					)
          self.assertTrue(
              abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)					)
              < 1e-3					)






      def 			UpperCAmelCase_       (		self:			Union[str, Any]	,    __lowerCamelCase:			Dict=False					):
          '''simple docstring'''


          def _inputs_have_equal_length(__lowerCamelCase:			Dict					):
              UpperCamelCase__:	Optional[int]					=     len(input[0]					)
              for input_slice in input[1:]:
                  if len(__lowerCamelCase					) != length:
                      return False
              return True

          def _inputs_are_equal(__lowerCamelCase:			Tuple	,    __lowerCamelCase:			str					):
              if len(__lowerCamelCase					) != len(__lowerCamelCase					):
                  return False

              for input_slice_a, input_slice_a in zip(__lowerCamelCase	,    __lowerCamelCase					):
                  if not np.allclose(np.asarray(__lowerCamelCase					)	,    np.asarray(__lowerCamelCase					)	,    atol=1e-3					):
                      return False
              return True

          UpperCamelCase__:	Any					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	Optional[Any]					=     self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCamelCase					)
          UpperCamelCase__:	Optional[Any]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	List[str]					=     BatchFeature({input_name: speech_inputs}					)

          # truncate to smallest
          UpperCamelCase__:	List[str]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)	,    truncation=__lowerCamelCase					)
          UpperCamelCase__:	Dict					=     input_a[input_name]

          UpperCamelCase__:	Optional[Any]					=     feat_extract.pad(__lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)					)
          UpperCamelCase__:	str					=     input_a[input_name]

          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertFalse(_inputs_have_equal_length(__lowerCamelCase					)					)

          # truncate to smallest with np
          UpperCamelCase__:	Optional[Any]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)	,    return_tensors="np"	,    truncation=__lowerCamelCase	,    )
          UpperCamelCase__:	Dict					=     input_a[input_name]

          UpperCamelCase__:	Optional[int]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)	,    return_tensors="np"					)
          UpperCamelCase__:	Union[str, Any]					=     input_a[input_name]

          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(input_a.shape[1] == len(speech_inputs[0]					)					)

          # since truncation forces padding to be smaller than longest input
          # function can't return `np.ndarray`, but has to return list
          self.assertFalse(_inputs_have_equal_length(__lowerCamelCase					)					)

          # truncate to middle
          UpperCamelCase__:	List[Any]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[1]					)	,    truncation=__lowerCamelCase	,    return_tensors="np"	,    )
          UpperCamelCase__:	str					=     input_a[input_name]

          UpperCamelCase__:	Union[str, Any]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[1]					)	,    truncation=__lowerCamelCase					)
          UpperCamelCase__:	Tuple					=     input_a[input_name]

          UpperCamelCase__:	Optional[int]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[1]					)	,    return_tensors="np"					)
          UpperCamelCase__:	Union[str, Any]					=     input_a[input_name]

          self.assertTrue(input_a.shape[1] == len(speech_inputs[1]					)					)
          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(_inputs_are_equal(__lowerCamelCase	,    __lowerCamelCase					)					)

          # since truncation forces padding to be smaller than longest input
          # function can't return `np.ndarray`, but has to return list
          self.assertFalse(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertTrue(len(input_a[-1]					) == len(speech_inputs[-1]					)					)

          # padding has to be max_length when setting `truncation=True`
          with self.assertRaises(__lowerCamelCase					):
              feat_extract.pad(__lowerCamelCase	,    truncation=__lowerCamelCase					)[input_name]

          # padding has to be max_length when setting `truncation=True`
          with self.assertRaises(__lowerCamelCase					):
              feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    truncation=__lowerCamelCase					)[input_name]

          # padding has to be max_length when setting `truncation=True`
          with self.assertRaises(__lowerCamelCase					):
              feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    truncation=__lowerCamelCase					)[input_name]

          # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
          with self.assertRaises(__lowerCamelCase					):
              feat_extract.pad(__lowerCamelCase	,    padding="max_length"	,    truncation=__lowerCamelCase					)[input_name]

          # test truncation for `pad_to_multiple_of` for List[int] + numpy
          UpperCamelCase__:	Tuple					=     12
          UpperCamelCase__:	Optional[int]					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)	,    pad_to_multiple_of=__lowerCamelCase	,    truncation=__lowerCamelCase	,    )
          UpperCamelCase__:	str					=     input_a[input_name]

          UpperCamelCase__:	str					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=len(speech_inputs[0]					)	,    pad_to_multiple_of=__lowerCamelCase	,    )
          UpperCamelCase__:	List[Any]					=     input_a[input_name]

          # retrieve expected_length as multiple of pad_to_multiple_of
          UpperCamelCase__:	Optional[int]					=     len(speech_inputs[0]					)
          if expected_length % pad_to_multiple_of != 0:
              UpperCamelCase__:	int					=     ((len(speech_inputs[0]					) // pad_to_multiple_of) + 1) * pad_to_multiple_of

          self.assertTrue(len(input_a[0]					) == expected_length					)
          self.assertTrue(_inputs_have_equal_length(__lowerCamelCase					)					)
          self.assertFalse(_inputs_have_equal_length(__lowerCamelCase					)					)






      def 			UpperCAmelCase_       (		self:			Tuple					):
          '''simple docstring'''


          self._check_padding(numpify=__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			str					):
          '''simple docstring'''


          self._check_padding(numpify=__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Dict					):
          '''simple docstring'''


          self._check_truncation(numpify=__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          self._check_truncation(numpify=__lowerCamelCase					)






      @require_torch
      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	Optional[int]					=     self.feat_extract_tester.prepare_inputs_for_common()
          UpperCamelCase__:	Union[str, Any]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Tuple					=     BatchFeature({input_name: speech_inputs}					)

          UpperCamelCase__:	Tuple					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="np"					)[input_name]
          UpperCamelCase__:	int					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="pt"					)[input_name]

          self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)






      @require_tf
      def 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          UpperCamelCase__:	Any					=     self.feature_extraction_class(**self.feat_extract_dict					)
          UpperCamelCase__:	Union[str, Any]					=     self.feat_extract_tester.prepare_inputs_for_common()
          UpperCamelCase__:	str					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	List[Any]					=     BatchFeature({input_name: speech_inputs}					)

          UpperCamelCase__:	Union[str, Any]					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="np"					)[input_name]
          UpperCamelCase__:	List[Any]					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="tf"					)[input_name]

          self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_tf.numpy().astype(np.floataa					).sum()					) < 1e-2					)






      def 			UpperCAmelCase_       (		self:			str					):
          '''simple docstring'''


          UpperCamelCase__:	Dict					=     self.feat_extract_dict
          UpperCamelCase__:	List[str]					=     True
          UpperCamelCase__:	Optional[Any]					=     self.feature_extraction_class(**__lowerCamelCase					)
          UpperCamelCase__:	Union[str, Any]					=     self.feat_extract_tester.prepare_inputs_for_common()
          UpperCamelCase__:	int					=     [len(__lowerCamelCase					) for x in speech_inputs]
          UpperCamelCase__:	List[Any]					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Dict					=     BatchFeature({input_name: speech_inputs}					)

          UpperCamelCase__:	List[Any]					=     feat_extract.pad(__lowerCamelCase	,    padding="longest"	,    return_tensors="np"					)
          self.assertIn("attention_mask"	,    __lowerCamelCase					)
          self.assertListEqual(list(processed.attention_mask.shape					)	,    list(processed[input_name].shape[:2]					)					)
          self.assertListEqual(processed.attention_mask.sum(-1					).tolist()	,    __lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	List[Any]					=     self.feat_extract_dict
          UpperCamelCase__:	List[Any]					=     True
          UpperCamelCase__:	Optional[int]					=     self.feature_extraction_class(**__lowerCamelCase					)
          UpperCamelCase__:	Any					=     self.feat_extract_tester.prepare_inputs_for_common()
          UpperCamelCase__:	List[Any]					=     [len(__lowerCamelCase					) for x in speech_inputs]
          UpperCamelCase__:	str					=     feat_extract.model_input_names[0]

          UpperCamelCase__:	Dict					=     BatchFeature({input_name: speech_inputs}					)
          UpperCamelCase__:	Optional[int]					=     min(__lowerCamelCase					)

          UpperCamelCase__:	Tuple					=     feat_extract.pad(
              __lowerCamelCase	,    padding="max_length"	,    max_length=__lowerCamelCase	,    truncation=__lowerCamelCase	,    return_tensors="np"					)
          self.assertIn("attention_mask"	,    __lowerCamelCase					)
          self.assertListEqual(
              list(processed_pad.attention_mask.shape					)	,    [processed_pad[input_name].shape[0], max_length]					)
          self.assertListEqual(
              processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()	,    [max_length for x in speech_inputs]					)

