'''simple docstring'''




import json
import os
from typing import Dict, List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__UpperCAmelCase					=logging.get_logger(__name__)


__UpperCAmelCase					={
    "vocab_file": "vocab.json",
    "tokenizer_config_file": "tokenizer_config.json",
    "merges_file": "merges.txt",
}

__UpperCAmelCase					={
    "vocab_file": {
        "facebook/s2t-wav2vec2-large-en-de": (
            "https://huggingface.co/facebook/s2t-wav2vec2-large-en-de/resolve/main/vocab.json"
        ),
    },
    "tokenizer_config_file": {
        "facebook/s2t-wav2vec2-large-en-de": (
            "https://huggingface.co/facebook/s2t-wav2vec2-large-en-de/resolve/main/tokenizer_config.json"
        ),
    },
    "merges_file": {
        "facebook/s2t-wav2vec2-large-en-de": (
            "https://huggingface.co/facebook/s2t-wav2vec2-large-en-de/resolve/main/merges.txt"
        ),
    },
}

__UpperCAmelCase					="</w>"
__UpperCAmelCase					="@@ "






def __lowerCAmelCase					(				UpperCamelCase__							)      ->       Tuple:
    __lowerCamelCase            =    set()
    __lowerCamelCase            =    word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)							)
        __lowerCamelCase            =    char
    return pairs


# Speech2Text2 has no max input length
__UpperCAmelCase					={"facebook/s2t-wav2vec2-large-en-de": 1_0_2_4}




class        a__ (  UpperCAmelCase__					):
     lowerCamelCase    :	Any				=VOCAB_FILES_NAMES
     lowerCamelCase    :	List[str]				=PRETRAINED_VOCAB_FILES_MAP
     lowerCamelCase    :	List[str]				=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     lowerCamelCase    :	Union[str, Any]				=["input_ids", "attention_mask"]






     def __init__(					self						:						Dict    ,							a						:						Optional[int]    ,							a						:						int="<s>"    ,							a						:						Optional[int]="<pad>"    ,							a						:						Any="</s>"    ,							a						:						str="<unk>"    ,							a						:						Optional[int]=False    ,							a						:						int=None    ,							**a						:						Dict    ,							):





         """simple docstring"""



         super().__init__(
             unk_token=a    ,							bos_token=a    ,							eos_token=a    ,							pad_token=a    ,							do_lower_case=a    ,							**a    ,							)

         __lowerCamelCase            =    do_lower_case

         with open(a    ,							encoding='''utf-8'''       ) as vocab_handle:
             __lowerCamelCase            =    json.load(a       )
         __lowerCamelCase            =    {v: k for k, v in self.encoder.items()}

         if merges_file is None:
             logger.info(f"""No merges files provided. {self.__class__.__name__} can only be used for decoding."""       )

             __lowerCamelCase            =    None
             __lowerCamelCase            =    None
         else:
             with open(a    ,							encoding='''utf-8'''       ) as merges_handle:
                 __lowerCamelCase            =    merges_handle.read().split('''\n'''       )[:-1]

             __lowerCamelCase            =    [tuple(merge.split()[:2]       ) for merge in merges]
             __lowerCamelCase            =    dict(zip(a    ,							range(len(a       )       )       )       )
             __lowerCamelCase            =    {}






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         return len(self.decoder       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         return dict(self.encoder    ,							**self.added_tokens_encoder       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[str]    ,							a						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase            =    tuple(token[:-1]       ) + (token[-1] + BPE_TOKEN_MERGES,)
         if token in self.cache:
             return self.cache[token]
         __lowerCamelCase            =    get_pairs(a       )

         if not pairs:
             return token

         while True:
             __lowerCamelCase            =    min(a    ,							key=lambda a       : self.bpe_ranks.get(a    ,							float('''inf'''       )       )       )
             if bigram not in self.bpe_ranks:
                 break
             __lowerCamelCase      ,    __lowerCamelCase            =    bigram
             __lowerCamelCase            =    []
             __lowerCamelCase            =    0
             while i < len(a       ):
                 try:
                     __lowerCamelCase            =    word.index(a    ,							a       )
                 except ValueError:
                     new_word.extend(word[i:]       )
                     break
                 else:
                     new_word.extend(word[i:j]       )
                     __lowerCamelCase            =    j

                 if word[i] == first and i < len(a       ) - 1 and word[i + 1] == second:
                     new_word.append(first + second       )
                     i += 2
                 else:
                     new_word.append(word[i]       )
                     i += 1
             __lowerCamelCase            =    tuple(a       )
             __lowerCamelCase            =    new_word
             if len(a       ) == 1:
                 break
             else:
                 __lowerCamelCase            =    get_pairs(a       )
         __lowerCamelCase            =    ''' '''.join(a       )
         if word == "\n  " + BPE_TOKEN_MERGES:
             __lowerCamelCase            =    '''\n''' + BPE_TOKEN_MERGES

         if word.endswith(a       ):
             __lowerCamelCase            =    word.replace(a    ,							''''''       )

         __lowerCamelCase            =    word.replace(''' '''    ,							a       )
         __lowerCamelCase            =    word
         return word






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]    ,							a						:						Dict       ):





         """simple docstring"""



         if self.bpe_ranks is None:
             raise ValueError(
                 '''This tokenizer was instantiated without a `merges.txt` file, so'''
                 ''' that it can only be used for decoding, not for encoding.'''
                 '''Make sure to provide `merges.txt` file at instantiation to enable '''
                 '''encoding.'''       )

         if self.do_lower_case:
             __lowerCamelCase            =    text.lower()

         __lowerCamelCase            =    text.split()

         __lowerCamelCase            =    []
         for token in text:
             if token:
                 split_tokens.extend(list(self.bpe(a       ).split(''' '''       )       )       )

         return split_tokens






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict    ,							a						:						str       ):





         """simple docstring"""



         return self.encoder.get(a    ,							self.encoder.get(self.unk_token       )       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any    ,							a						:						int       ):





         """simple docstring"""



         __lowerCamelCase            =    self.decoder.get(a    ,							self.unk_token       )
         return result






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase            =    ''' '''.join(a       )

         # make sure @@ tokens are concatenated
         __lowerCamelCase            =    ''''''.join(string.split(a       )       )

         return string






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						str    ,							a						:						Optional[str] = None       ):





         """simple docstring"""



         if not os.path.isdir(a       ):
             logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""       )
             return
         __lowerCamelCase            =    os.path.join(
             a    ,							(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']       )
         __lowerCamelCase            =    os.path.join(
             a    ,							(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']       )

         with open(a    ,							'''w'''    ,							encoding='''utf-8'''       ) as f:
             f.write(json.dumps(self.encoder    ,							indent=2    ,							sort_keys=a    ,							ensure_ascii=a       ) + '''\n'''       )

         __lowerCamelCase            =    0
         if self.bpe_ranks is None:
             return (vocab_file,)

         with open(a    ,							'''w'''    ,							encoding='''utf-8'''       ) as writer:
             for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,							key=lambda a       : kv[1]       ):
                 if index != token_index:
                     logger.warning(
                         f"""Saving vocabulary to {merges_file}: BPE merge indices are not consecutive."""
                         ''' Please check that the tokenizer is not corrupted!'''       )
                     __lowerCamelCase            =    token_index
                 writer.write(''' '''.join(a       ) + '''\n'''       )
                 index += 1

         return (vocab_file, merges_file)

'''simple docstring'''




from manim import *




class        a__ (  UpperCAmelCase__					):






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]       ):





         """simple docstring"""



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

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

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

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

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

         __lowerCamelCase            =    Text('''Model'''    ,							font_size=24       )
         __lowerCamelCase            =    Group(a    ,							a       ).arrange(a    ,							buff=0.5    ,							aligned_edge=a       )
         model.move_to([3, -1.0, 0]       )
         self.add(a       )

         __lowerCamelCase            =    []
         __lowerCamelCase            =    []

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

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

         self.add(*a    ,							*a       )

         __lowerCamelCase            =    [meta_mem.copy() for i in range(6       )]
         __lowerCamelCase            =    [meta_mem.copy() for i in range(6       )]
         __lowerCamelCase            =    VGroup(*a       ).arrange(a    ,							buff=0       )
         __lowerCamelCase            =    VGroup(*a       ).arrange(a    ,							buff=0       )
         __lowerCamelCase            =    VGroup(a    ,							a       ).arrange(a    ,							buff=0       )
         __lowerCamelCase            =    Text('''Disk'''    ,							font_size=24       )
         __lowerCamelCase            =    Group(a    ,							a       ).arrange(a    ,							buff=0.5    ,							aligned_edge=a       )
         disk.move_to([-4, -1.25, 0]       )
         self.add(a    ,							a       )

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

         __lowerCamelCase            =    MarkupText(
             f"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""    ,							font_size=18    ,							)

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

         self.add(a    ,							a       )

         __lowerCamelCase            =    MarkupText(
             f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""    ,							font_size=18    ,							)

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

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

         self.play(Write(a       )       )

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

         self.play(Write(a       )       )

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

         self.play(FadeOut(a       )       )

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

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

         __lowerCamelCase            =    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=24    ,							)
         step_a.move_to([2, 2, 0]       )

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

         __lowerCamelCase            =    {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

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

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

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

             __lowerCamelCase            =    AnimationGroup(
                 FadeOut(a    ,							run_time=0.5       )    ,							MoveToTarget(a    ,							run_time=0.5       )    ,							FadeIn(a    ,							run_time=0.5       )    ,							lag_ratio=0.2       )

             self.play(a       )

             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:
                     __lowerCamelCase            =    0.7

                 self.play(
                     Circumscribe(model_arr[i]    ,							**a       )    ,							Circumscribe(cpu_left_col_base[i]    ,							**a       )    ,							Circumscribe(cpu_left_col_base[i + 1]    ,							color=a    ,							**a       )    ,							Circumscribe(gpu_rect[0]    ,							color=a    ,							**a       )    ,							Circumscribe(model_arr[i + 1]    ,							color=a    ,							**a       )    ,							)
                 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=a    ,							**a       )    ,							Circumscribe(cpu_left_col_base[-1]    ,							color=a    ,							**a       )    ,							Circumscribe(gpu_rect[0]    ,							color=a    ,							**a       )    ,							)

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

             __lowerCamelCase            =    a_c
             __lowerCamelCase            =    a_c.copy()

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

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

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

         self.wait()
