






'''simple docstring'''



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 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      # to overwrite at feature extractactor specific tests
      __a	       =None
      __a	       =None




      @property
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         return self.feat_extract_tester.prepare_feat_extract_dict()




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     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   )				->str:



         '''simple docstring'''
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common()
         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

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

         __a					  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase   )
         __a					  =     BatchFeature({input_name: speech_inputs}			, tensor_type='np'   )

         __a					  =     processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
            __a					  =     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   )				->Dict:



         '''simple docstring'''
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase   )
         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}			, tensor_type='pt'   )

         __a					  =     processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
            __a					  =     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   )				->Union[str, Any]:



         '''simple docstring'''
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase   )
         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}			, tensor_type='tf'   )

         __a					  =     processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
            __a					  =     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			, lowerCamelCase=False   )				->Optional[Any]:



         '''simple docstring'''
         def _inputs_have_equal_length(lowerCamelCase   ):
            __a					  =     len(input[0]   )
            for input_slice in input[1:]:
               if len(lowerCamelCase   ) != length:
                  return False
            return True

         def _inputs_are_equal(lowerCamelCase			, lowerCamelCase   ):
            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

         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase   )
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

         __a					  =     self.feat_extract_tester.seq_length_diff
         __a					  =     self.feat_extract_tester.max_seq_length + pad_diff
         __a					  =     self.feat_extract_tester.min_seq_length
         __a					  =     self.feat_extract_tester.batch_size
         __a					  =     self.feat_extract_tester.feature_size

         # test padding for List[int] + numpy
         __a					  =     feat_extract.pad(lowerCamelCase			, padding=lowerCamelCase   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='longest'   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[-1]   )   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='longest'			, return_tensors='np'   )
         __a					  =     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]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=lowerCamelCase			, return_tensors='np'   )
         __a					  =     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
         __a					  =     feat_extract.pad(lowerCamelCase			, pad_to_multiple_of=10   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='longest'			, pad_to_multiple_of=10   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, pad_to_multiple_of=10			, max_length=lowerCamelCase   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, pad_to_multiple_of=10			, max_length=lowerCamelCase			, return_tensors='np'			, )
         __a					  =     input_a[input_name]

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

         __a					  =     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
         __a					  =     (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			, lowerCamelCase=False   )				->Optional[int]:



         '''simple docstring'''
         def _inputs_have_equal_length(lowerCamelCase   ):
            __a					  =     len(input[0]   )
            for input_slice in input[1:]:
               if len(lowerCamelCase   ) != length:
                  return False
            return True

         def _inputs_are_equal(lowerCamelCase			, lowerCamelCase   ):
            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

         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase   )
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

         # truncate to smallest
         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )			, truncation=lowerCamelCase   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )   )
         __a					  =     input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(lowerCamelCase   )   )
         self.assertFalse(_inputs_have_equal_length(lowerCamelCase   )   )

         # truncate to smallest with np
         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )			, return_tensors='np'			, truncation=lowerCamelCase			, )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )			, return_tensors='np'   )
         __a					  =     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
         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[1]   )			, truncation=lowerCamelCase			, return_tensors='np'			, )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[1]   )			, truncation=lowerCamelCase   )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[1]   )			, return_tensors='np'   )
         __a					  =     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
         __a					  =     12
         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )			, pad_to_multiple_of=lowerCamelCase			, truncation=lowerCamelCase			, )
         __a					  =     input_a[input_name]

         __a					  =     feat_extract.pad(
             lowerCamelCase			, padding='max_length'			, max_length=len(speech_inputs[0]   )			, pad_to_multiple_of=lowerCamelCase			, )
         __a					  =     input_a[input_name]

         # retrieve expected_length as multiple of pad_to_multiple_of
         __a					  =     len(speech_inputs[0]   )
         if expected_length % pad_to_multiple_of != 0:
            __a					  =     ((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   )				->Optional[int]:



         '''simple docstring'''
         self._check_padding(numpify=lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         self._check_padding(numpify=lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         self._check_truncation(numpify=lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         self._check_truncation(numpify=lowerCamelCase   )




      @require_torch
      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common()
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='longest'			, return_tensors='np'   )[input_name]
         __a					  =     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   )				->Any:



         '''simple docstring'''
         __a					  =     self.feature_extraction_class(**self.feat_extract_dict   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common()
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

         __a					  =     feat_extract.pad(lowerCamelCase			, padding='longest'			, return_tensors='np'   )[input_name]
         __a					  =     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   )				->Tuple:



         '''simple docstring'''
         __a					  =     self.feat_extract_dict
         __a					  =     True
         __a					  =     self.feature_extraction_class(**lowerCamelCase   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common()
         __a					  =     [len(lowerCamelCase   ) for x in speech_inputs]
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )

         __a					  =     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'''
         __a					  =     self.feat_extract_dict
         __a					  =     True
         __a					  =     self.feature_extraction_class(**lowerCamelCase   )
         __a					  =     self.feat_extract_tester.prepare_inputs_for_common()
         __a					  =     [len(lowerCamelCase   ) for x in speech_inputs]
         __a					  =     feat_extract.model_input_names[0]

         __a					  =     BatchFeature({input_name: speech_inputs}   )
         __a					  =     min(lowerCamelCase   )

         __a					  =     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]   )







'''simple docstring'''



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   if not all(x.isalpha() for x in string     ):
      raise ValueError('String must only contain alphabetic characters.'     )

   __a					  =     sorted(string.lower()     )
   return len(SCREAMING_SNAKE_CASE__     ) == len(set(SCREAMING_SNAKE_CASE__     )     )


if __name__ == "__main__":
 __UpperCamelCase   :							int         =   input("""Enter a string """).strip()

 __UpperCamelCase   :							Tuple         =   is_isogram(input_str)
 print(f"""{input_str} is {"an" if isogram else "not an"} isogram.""")