import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : str      =			'Speech2TextFeatureExtractor'
   __UpperCAmelCase : int      =			'Speech2TextTokenizer'


   def __init__(self     :						Any       ,  __UpperCAmelCase     :						Dict       ,  __UpperCAmelCase     :						Union[str, Any]		)						->				int:
         """simple docstring"""



         super().__init__(__UpperCAmelCase       ,  __UpperCAmelCase		)
         UpperCAmelCase__								=  self.feature_extractor
         UpperCAmelCase__								=  False


   def __call__(self     :						Any       ,  *__UpperCAmelCase     :						Optional[Any]       ,  **__UpperCAmelCase     :						Optional[Any]		)						->				List[str]:
         """simple docstring"""



         if self._in_target_context_manager:
               return self.current_processor(*__UpperCAmelCase       ,  **__UpperCAmelCase		)

         if "raw_speech" in kwargs:
               warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."		)
               UpperCAmelCase__								=  kwargs.pop("raw_speech"		)
         else:
               UpperCAmelCase__								=  kwargs.pop("audio"       ,  __UpperCAmelCase		)
         UpperCAmelCase__								=  kwargs.pop("sampling_rate"       ,  __UpperCAmelCase		)
         UpperCAmelCase__								=  kwargs.pop("text"       ,  __UpperCAmelCase		)
         if len(__UpperCAmelCase		) > 0:
               UpperCAmelCase__								=  args[0]
               UpperCAmelCase__								=  args[1:]

         if audio is None and text is None:
               raise ValueError("You need to specify either an `audio` or `text` input to process."		)

         if audio is not None:
               UpperCAmelCase__								=  self.feature_extractor(__UpperCAmelCase       ,  *__UpperCAmelCase       ,  sampling_rate=__UpperCAmelCase       ,  **__UpperCAmelCase		)
         if text is not None:
               UpperCAmelCase__								=  self.tokenizer(__UpperCAmelCase       ,  **__UpperCAmelCase		)

         if text is None:
               return inputs
         elif audio is None:
               return encodings
         else:
               UpperCAmelCase__								=  encodings["input_ids"]
               return inputs


   def 			lowercase_      (self     :						Optional[Any]       ,  *__UpperCAmelCase     :						str       ,  **__UpperCAmelCase     :						Optional[int]		)						->				Dict:
         """simple docstring"""



         return self.tokenizer.batch_decode(*__UpperCAmelCase       ,  **__UpperCAmelCase		)


   def 			lowercase_      (self     :						Optional[Any]       ,  *__UpperCAmelCase     :						str       ,  **__UpperCAmelCase     :						Optional[int]		)						->				Union[str, Any]:
         """simple docstring"""



         return self.tokenizer.decode(*__UpperCAmelCase       ,  **__UpperCAmelCase		)





   @contextmanager
   def 			lowercase_      (self     :						Dict		)						->				str:
         """simple docstring"""



         warnings.warn(
             "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
             "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
             "your audio inputs, or in a separate call."		)
         UpperCAmelCase__								=  True
         UpperCAmelCase__								=  self.tokenizer
         yield
         UpperCAmelCase__								=  self.feature_extractor
         UpperCAmelCase__								=  False




from manim import *





class      A							(				UpperCAmelCase_     ):


   def 			lowercase_      (self     :						Union[str, Any]		)						->				List[str]:
         """simple docstring"""



         UpperCAmelCase__								=  Rectangle(height=0.5       ,  width=0.5		)
         UpperCAmelCase__								=  Rectangle(height=0.46       ,  width=0.46		).set_stroke(width=0		)

         UpperCAmelCase__								=  Rectangle(height=0.25       ,  width=0.25		)

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

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

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

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

         UpperCAmelCase__								=  []
         UpperCAmelCase__								=  []

         for i, rect in enumerate(__UpperCAmelCase		):
               UpperCAmelCase__								=  fill.copy().set_fill(__UpperCAmelCase       ,  opacity=0.8		)
               target.move_to(__UpperCAmelCase		)
               model_arr.append(__UpperCAmelCase		)

               UpperCAmelCase__								=  Rectangle(height=0.46       ,  width=0.46		).set_stroke(width=0.0		).set_fill(__UpperCAmelCase       ,  opacity=0.8		)
               cpu_target.move_to(cpu_left_col_base[i]		)
               model_cpu_arr.append(__UpperCAmelCase		)

         self.add(*__UpperCAmelCase       ,  *__UpperCAmelCase		)

         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("Disk"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         disk.move_to([-4, -1.25, 0]		)
         self.add(__UpperCAmelCase       ,  __UpperCAmelCase		)

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

         UpperCAmelCase__								=  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(__UpperCAmelCase       ,  __UpperCAmelCase		)

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

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

         UpperCAmelCase__								=  MarkupText(
             f"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""       ,  font_size=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase		)		)

         UpperCAmelCase__								=  Square(0.3		)
         input.set_fill(__UpperCAmelCase       ,  opacity=1.0		)
         input.set_stroke(width=0.0		)
         input.next_to(model_base[0]       ,  __UpperCAmelCase       ,  buff=0.5		)

         self.play(Write(__UpperCAmelCase		)		)

         input.generate_target()
         input.target.next_to(model_arr[0]       ,  direction=__UpperCAmelCase       ,  buff=0.02		)
         self.play(MoveToTarget(__UpperCAmelCase		)		)

         self.play(FadeOut(__UpperCAmelCase		)		)

         UpperCAmelCase__								=  Arrow(start=__UpperCAmelCase       ,  end=__UpperCAmelCase       ,  color=__UpperCAmelCase       ,  buff=0.5		)
         a.next_to(model_arr[0].get_left()       ,  __UpperCAmelCase       ,  buff=0.2		)

         model_cpu_arr[0].generate_target()
         model_cpu_arr[0].target.move_to(gpu_rect[0]		)

         UpperCAmelCase__								=  MarkupText(
             f"""As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."""       ,  font_size=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

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

         UpperCAmelCase__								=  {"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.02}

         self.play(
             Write(__UpperCAmelCase		)       ,  Circumscribe(model_arr[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(model_cpu_arr[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )
         self.play(MoveToTarget(model_cpu_arr[0]		)		)

         UpperCAmelCase__								=  a.copy()
         for i in range(6		):
               a_c.next_to(model_arr[i].get_right() + 0.02       ,  __UpperCAmelCase       ,  buff=0.2		)

               input.generate_target()
               input.target.move_to(model_arr[i].get_right() + 0.02		)

               UpperCAmelCase__								=  AnimationGroup(
                   FadeOut(__UpperCAmelCase       ,  run_time=0.5		)       ,  MoveToTarget(__UpperCAmelCase       ,  run_time=0.5		)       ,  FadeIn(__UpperCAmelCase       ,  run_time=0.5		)       ,  lag_ratio=0.2		)

               self.play(__UpperCAmelCase		)

               model_cpu_arr[i].generate_target()
               model_cpu_arr[i].target.move_to(cpu_left_col_base[i]		)

               if i < 5:
                     model_cpu_arr[i + 1].generate_target()
                     model_cpu_arr[i + 1].target.move_to(gpu_rect[0]		)
                     if i >= 1:
                           UpperCAmelCase__								=  0.7

                     self.play(
                         Circumscribe(model_arr[i]       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[i]       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[i + 1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(model_arr[i + 1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )
                     if i < 1:
                           self.play(
                               MoveToTarget(model_cpu_arr[i]		)       ,  MoveToTarget(model_cpu_arr[i + 1]		)       ,  )
                     else:
                           self.play(
                               MoveToTarget(model_cpu_arr[i]       ,  run_time=0.7		)       ,  MoveToTarget(model_cpu_arr[i + 1]       ,  run_time=0.7		)       ,  )
               else:
                     model_cpu_arr[i].generate_target()
                     model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]		)
                     input.generate_target()
                     input.target.next_to(model_arr[-1].get_right()       ,  RIGHT + 0.02       ,  buff=0.2		)

                     self.play(
                         Circumscribe(model_arr[-1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[-1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )

                     self.play(MoveToTarget(model_cpu_arr[i]		)		)

               UpperCAmelCase__								=  a_c
               UpperCAmelCase__								=  a_c.copy()

         input.generate_target()
         input.target.next_to(model_base[-1]       ,  RIGHT + 0.02       ,  buff=0.5		)
         self.play(
             FadeOut(__UpperCAmelCase		)       ,  FadeOut(__UpperCAmelCase       ,  run_time=0.5		)       ,  )

         UpperCAmelCase__								=  MarkupText(f"""Inference on a model too large for GPU memory\nis successfully completed."""       ,  font_size=2_4		)
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase       ,  run_time=3		)       ,  MoveToTarget(__UpperCAmelCase		)		)

         self.wait()



