



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      _UpperCAmelCase      (							A__  ):
     # to overwrite at feature extractactor specific tests
     UpperCamelCase__		     =					None
     UpperCamelCase__		     =					None




     @property
     def 		snake_case_		(					self):
         return self.feat_extract_tester.prepare_feat_extract_dict()




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_dict)
         self.assertTrue(hasattr(a__			,    '''feature_size'''))
         self.assertTrue(hasattr(a__			,    '''sampling_rate'''))
         self.assertTrue(hasattr(a__			,    '''padding_value'''))




     def 		snake_case_		(					self):
         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(a__) == len(a__) for x, y in zip(a__			,    processed_features[input_name])))

         A__					=       self.feat_extract_tester.prepare_inputs_for_common(equal_length=a__)
         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 		snake_case_		(					self):
         A__					=       self.feat_extract_tester.prepare_inputs_for_common(equal_length=a__)
         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 		snake_case_		(					self):
         A__					=       self.feat_extract_tester.prepare_inputs_for_common(equal_length=a__)
         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 		snake_case_		(					self			,    a__=False):
         def _inputs_have_equal_length(a__):
             A__					=       len(input[0])
             for input_slice in input[1:]:
                 if len(a__) != length:
                     return False
             return True

         def _inputs_are_equal(a__			,    a__):
             if len(a__) != len(a__):
                 return False

             for input_slice_a, input_slice_a in zip(a__			,    a__):
                 if not np.allclose(np.asarray(a__)			,    np.asarray(a__)			,    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=a__)
         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(a__			,    padding=a__)
         A__					=       input_a[input_name]

         A__					=       feat_extract.pad(a__			,    padding='''longest''')
         A__					=       input_a[input_name]

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

         A__					=       feat_extract.pad(a__			,    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(a__):
             feat_extract.pad(a__			,    padding='''max_length''')[input_name]

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=a__			,    return_tensors='''np''')
         A__					=       input_a[input_name]

         self.assertFalse(_inputs_have_equal_length(a__))
         self.assertTrue(_inputs_have_equal_length(a__))
         self.assertTrue(_inputs_have_equal_length(a__))
         self.assertTrue(_inputs_are_equal(a__			,    a__))
         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(a__			,    pad_to_multiple_of=1_0)
         A__					=       input_a[input_name]

         A__					=       feat_extract.pad(a__			,    padding='''longest'''			,    pad_to_multiple_of=1_0)
         A__					=       input_a[input_name]

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    pad_to_multiple_of=1_0			,    max_length=a__)
         A__					=       input_a[input_name]

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    pad_to_multiple_of=1_0			,    max_length=a__			,    return_tensors='''np'''			,    )
         A__					=       input_a[input_name]

         self.assertTrue(all(len(a__) % 1_0 == 0 for x in input_a))
         self.assertTrue(_inputs_are_equal(a__			,    a__))

         A__					=       pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
         self.assertTrue(all(len(a__) == 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 		snake_case_		(					self			,    a__=False):
         def _inputs_have_equal_length(a__):
             A__					=       len(input[0])
             for input_slice in input[1:]:
                 if len(a__) != length:
                     return False
             return True

         def _inputs_are_equal(a__			,    a__):
             if len(a__) != len(a__):
                 return False

             for input_slice_a, input_slice_a in zip(a__			,    a__):
                 if not np.allclose(np.asarray(a__)			,    np.asarray(a__)			,    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=a__)
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})

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

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

         self.assertTrue(_inputs_have_equal_length(a__))
         self.assertFalse(_inputs_have_equal_length(a__))

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

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=len(speech_inputs[0])			,    return_tensors='''np''')
         A__					=       input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(a__))
         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(a__))

         # truncate to middle
         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=len(speech_inputs[1])			,    truncation=a__			,    return_tensors='''np'''			,    )
         A__					=       input_a[input_name]

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

         A__					=       feat_extract.pad(
             a__			,    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(a__))
         self.assertTrue(_inputs_have_equal_length(a__))
         self.assertTrue(_inputs_are_equal(a__			,    a__))

         # 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(a__))
         self.assertTrue(len(input_a[-1]) == len(speech_inputs[-1]))

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

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

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

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

         # test truncation for `pad_to_multiple_of` for List[int] + numpy
         A__					=       1_2
         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=len(speech_inputs[0])			,    pad_to_multiple_of=a__			,    truncation=a__			,    )
         A__					=       input_a[input_name]

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=len(speech_inputs[0])			,    pad_to_multiple_of=a__			,    )
         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(a__))
         self.assertFalse(_inputs_have_equal_length(a__))




     def 		snake_case_		(					self):
         self._check_padding(numpify=a__)




     def 		snake_case_		(					self):
         self._check_padding(numpify=a__)




     def 		snake_case_		(					self):
         self._check_truncation(numpify=a__)




     def 		snake_case_		(					self):
         self._check_truncation(numpify=a__)




     @require_torch
     def 		snake_case_		(					self):
         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(a__			,    padding='''longest'''			,    return_tensors='''np''')[input_name]
         A__					=       feat_extract.pad(a__			,    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 		snake_case_		(					self):
         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(a__			,    padding='''longest'''			,    return_tensors='''np''')[input_name]
         A__					=       feat_extract.pad(a__			,    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 		snake_case_		(					self):
         A__					=       self.feat_extract_dict
         A__					=       True
         A__					=       self.feature_extraction_class(**a__)
         A__					=       self.feat_extract_tester.prepare_inputs_for_common()
         A__					=       [len(a__) for x in speech_inputs]
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})

         A__					=       feat_extract.pad(a__			,    padding='''longest'''			,    return_tensors='''np''')
         self.assertIn('''attention_mask'''			,    a__)
         self.assertListEqual(list(processed.attention_mask.shape)			,    list(processed[input_name].shape[:2]))
         self.assertListEqual(processed.attention_mask.sum(-1).tolist()			,    a__)




     def 		snake_case_		(					self):
         A__					=       self.feat_extract_dict
         A__					=       True
         A__					=       self.feature_extraction_class(**a__)
         A__					=       self.feat_extract_tester.prepare_inputs_for_common()
         A__					=       [len(a__) for x in speech_inputs]
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})
         A__					=       min(a__)

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=a__			,    truncation=a__			,    return_tensors='''np''')
         self.assertIn('''attention_mask'''			,    a__)
         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])





from manim import *



class      _UpperCAmelCase      (							A__  ):




     def 		snake_case_		(					self):
         A__					=       Rectangle(height=0.5			,    width=0.5)
         A__					=       Rectangle(height=0.2_5			,    width=0.2_5)
         A__					=       Rectangle(height=0.4_6			,    width=0.4_6).set_stroke(width=0)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(a__			,    a__).arrange(a__			,    buff=0)
         A__					=       Text('''CPU'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         cpu.move_to([-2.5, -0.5, 0])
         self.add(a__)

         A__					=       [mem.copy() for i in range(4)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       Text('''GPU'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         gpu.move_to([-1, -1, 0])
         self.add(a__)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)

         A__					=       Text('''Model'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         model.move_to([3, -1.0, 0])
         self.add(a__)

         A__					=       []
         A__					=       []
         A__					=       []

         for i, rect in enumerate(a__):
             rect.set_stroke(a__)

             A__					=       Rectangle(height=0.4_6 / 4			,    width=0.4_6 / 3).set_stroke(width=0.0).set_fill(a__			,    opacity=0.7)

             if i == 0:
                 cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)			,    buff=0.0_2			,    direction=a__)
                 cpu_target.set_x(cpu_target.get_x() + 0.1)
             elif i == 3:
                 cpu_target.next_to(model_cpu_arr[0]			,    direction=a__			,    buff=0.0)
             else:
                 cpu_target.next_to(model_cpu_arr[i - 1]			,    direction=a__			,    buff=0.0)
             self.add(a__)
             model_cpu_arr.append(a__)

         self.add(*a__			,    *a__			,    *a__)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)

         A__					=       Text('''Loaded Checkpoint'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         checkpoint.move_to([3, 0.5, 0])

         self.add(a__)

         A__					=       []
         A__					=       []

         for i, rect in enumerate(a__):
             A__					=       fill.copy().set_fill(a__			,    opacity=0.7)
             target.move_to(a__)
             ckpt_arr.append(a__)

             A__					=       target.copy()
             if i < 5:
                 cpu_target.move_to(cpu_left_col_base[i + 1])
             else:
                 cpu_target.move_to(cpu_right_col_base[i - 5])
             ckpt_cpu_arr.append(a__)
         self.add(*a__			,    *a__)

         A__					=       Square(side_length=2.2)
         key.move_to([-5, 2, 0])

         A__					=       MarkupText(
             F"<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"			,    font_size=1_8			,    )

         key_text.move_to([-5, 2.4, 0])

         self.add(a__			,    a__)

         A__					=       MarkupText(
             F"<span fgcolor='{BLUE}'>●</span> Checkpoint"			,    font_size=1_8			,    )

         blue_text.next_to(a__			,    DOWN * 2.4			,    aligned_edge=key_text.get_left())
         self.add(a__)

         A__					=       MarkupText(
             F"Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device."			,    font_size=2_4			,    )
         step_a.move_to([2, 2, 0])

         A__					=       [meta_mem.copy() for i in range(6)]
         A__					=       [meta_mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(a__			,    a__).arrange(a__			,    buff=0)
         A__					=       Text('''Disk'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         disk.move_to([-4.0, -1.2_5, 0])
         self.play(Write(a__			,    run_time=3)			,    Write(a__			,    run_time=1)			,    Create(a__			,    run_time=1))

         A__					=       []
         for i, rect in enumerate(a__):
             A__					=       rect.copy()
             target.generate_target()
             target.target.move_to(disk_left_col_base[i]).scale(0.5)
             animations.append(MoveToTarget(a__			,    run_time=1.5))
         self.play(*a__)

         self.play(FadeOut(a__))

         A__					=       MarkupText(F"Then, the checkpoint is removed from memory\nthrough garbage collection."			,    font_size=2_4)
         step_a.move_to([2, 2, 0])

         self.play(Write(a__			,    run_time=3))

         self.play(
             FadeOut(a__			,    a__			,    *a__			,    *a__)			,    )

         self.wait()
