





'''simple docstring'''

from manim import *
class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""





       def snake_case__		(				self  :						Optional[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							       =			[mem.copy() for i in range(6	)]
            _UpperCamelCase							       =			[mem.copy() for i in range(6	)]
            _UpperCamelCase							       =			VGroup(*lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0	)
            _UpperCamelCase							       =			VGroup(*lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0	)
            _UpperCamelCase							       =			VGroup(lowerCAmelCase__			,					lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0	)
            _UpperCamelCase							       =			Text('''CPU'''			,					font_size=24	)
            _UpperCamelCase							       =			Group(lowerCAmelCase__			,					lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0.5			,					aligned_edge=lowerCAmelCase__	)
            cpu.move_to([-2.5, -0.5, 0]	)
            self.add(lowerCAmelCase__	)

            _UpperCamelCase							       =			[mem.copy() for i in range(1	)]
            _UpperCamelCase							       =			VGroup(*lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0	)
            _UpperCamelCase							       =			Text('''GPU'''			,					font_size=24	)
            _UpperCamelCase							       =			Group(lowerCAmelCase__			,					lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0.5			,					aligned_edge=lowerCAmelCase__	)
            gpu.align_to(lowerCAmelCase__			,					lowerCAmelCase__	)
            gpu.set_x(gpu.get_x() - 1	)

            self.add(lowerCAmelCase__	)

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

            _UpperCamelCase							       =			Text('''Model'''			,					font_size=24	)
            _UpperCamelCase							       =			Group(lowerCAmelCase__			,					lowerCAmelCase__	).arrange(lowerCAmelCase__			,					buff=0.5			,					aligned_edge=lowerCAmelCase__	)
            model.move_to([3, -1.0, 0]	)

            self.play(
                Create(lowerCAmelCase__			,					run_time=1	)			,					Create(lowerCAmelCase__			,					run_time=1	)			,					Create(lowerCAmelCase__			,					run_time=1	)			,					)

            _UpperCamelCase							       =			MarkupText(
                f"""First, an empty model skeleton is loaded\ninto <span fgcolor='{YELLOW}'>memory</span> without using much RAM."""			,					font_size=24			,					)

            _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=18			,					)

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

            step_a.move_to([2, 2, 0]	)
            self.play(Write(lowerCAmelCase__			,					run_time=2.5	)			,					Write(lowerCAmelCase__	)			,					Write(lowerCAmelCase__	)	)

            self.add(lowerCAmelCase__	)

            _UpperCamelCase							       =			[]
            _UpperCamelCase							       =			[]
            _UpperCamelCase							       =			[]
            for i, rect in enumerate(lowerCAmelCase__	):
                 _UpperCamelCase							       =			Rectangle(height=0.46			,					width=0.46	).set_stroke(width=0.0	).set_fill(lowerCAmelCase__			,					opacity=0.7	)
                 cpu_target.move_to(lowerCAmelCase__	)
                 cpu_target.generate_target()
                 _UpperCamelCase							       =			0.46 / 4
                 _UpperCamelCase							       =			0.46 / 3

                 if i == 0:
                      cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT	)			,					buff=0.02			,					direction=lowerCAmelCase__	)
                      cpu_target.target.set_x(cpu_target.target.get_x() + 0.1	)
                 elif i == 3:
                      cpu_target.target.next_to(cpu_targs[0].target			,					direction=lowerCAmelCase__			,					buff=0.0	)
                 else:
                      cpu_target.target.next_to(cpu_targs[i - 1].target			,					direction=lowerCAmelCase__			,					buff=0.0	)
                 cpu_targs.append(lowerCAmelCase__	)

                 first_animations.append(rect.animate(run_time=0.5	).set_stroke(lowerCAmelCase__	)	)
                 second_animations.append(MoveToTarget(lowerCAmelCase__			,					run_time=1.5	)	)

            self.play(*lowerCAmelCase__	)
            self.play(*lowerCAmelCase__	)

            self.wait()










'''simple docstring'''

from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""
       _snake_case      :	Dict									=       ['image_processor', 'tokenizer']
       _snake_case      :	int									=       'BlipImageProcessor'
       _snake_case      :	Tuple									=       ('BertTokenizer', 'BertTokenizerFast')





       def __init__(				self  :						Union[str, Any]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						List[str]	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			False
            super().__init__(lowerCAmelCase__			,					lowerCAmelCase__	)
            _UpperCamelCase							       =			self.image_processor





       def __call__(				self  :						int			,					lowerCAmelCase__  :						ImageInput = None			,					lowerCAmelCase__  :						Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None			,					lowerCAmelCase__  :						bool = True			,					lowerCAmelCase__  :						Union[bool, str, PaddingStrategy] = False			,					lowerCAmelCase__  :						Union[bool, str, TruncationStrategy] = None			,					lowerCAmelCase__  :						Optional[int] = None			,					lowerCAmelCase__  :						int = 0			,					lowerCAmelCase__  :						Optional[int] = None			,					lowerCAmelCase__  :						Optional[bool] = None			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						bool = True			,					lowerCAmelCase__  :						Optional[Union[str, TensorType]] = None			,					**lowerCAmelCase__  :						Optional[Any]			,					)       ->	BatchEncoding:

            '''simple docstring'''




            if images is None and text is None:
                 raise ValueError('''You have to specify either images or text.'''	)

            # Get only text
            if images is None:
                 _UpperCamelCase							       =			self.tokenizer
                 _UpperCamelCase							       =			self.tokenizer(
                     text=lowerCAmelCase__			,					add_special_tokens=lowerCAmelCase__			,					padding=lowerCAmelCase__			,					truncation=lowerCAmelCase__			,					max_length=lowerCAmelCase__			,					stride=lowerCAmelCase__			,					pad_to_multiple_of=lowerCAmelCase__			,					return_attention_mask=lowerCAmelCase__			,					return_overflowing_tokens=lowerCAmelCase__			,					return_special_tokens_mask=lowerCAmelCase__			,					return_offsets_mapping=lowerCAmelCase__			,					return_token_type_ids=lowerCAmelCase__			,					return_length=lowerCAmelCase__			,					verbose=lowerCAmelCase__			,					return_tensors=lowerCAmelCase__			,					**lowerCAmelCase__			,					)
                 return text_encoding

            # add pixel_values
            _UpperCamelCase							       =			self.image_processor(lowerCAmelCase__			,					return_tensors=lowerCAmelCase__	)

            if text is not None:
                 _UpperCamelCase							       =			self.tokenizer(
                     text=lowerCAmelCase__			,					add_special_tokens=lowerCAmelCase__			,					padding=lowerCAmelCase__			,					truncation=lowerCAmelCase__			,					max_length=lowerCAmelCase__			,					stride=lowerCAmelCase__			,					pad_to_multiple_of=lowerCAmelCase__			,					return_attention_mask=lowerCAmelCase__			,					return_overflowing_tokens=lowerCAmelCase__			,					return_special_tokens_mask=lowerCAmelCase__			,					return_offsets_mapping=lowerCAmelCase__			,					return_token_type_ids=lowerCAmelCase__			,					return_length=lowerCAmelCase__			,					verbose=lowerCAmelCase__			,					return_tensors=lowerCAmelCase__			,					**lowerCAmelCase__			,					)
            else:
                 _UpperCamelCase							       =			None

            if text_encoding is not None:
                 encoding_image_processor.update(lowerCAmelCase__	)

            return encoding_image_processor





       def snake_case__		(				self  :						Any			,					*lowerCAmelCase__  :						Union[str, Any]			,					**lowerCAmelCase__  :						Dict	)       ->	List[str]:

            '''simple docstring'''




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





       def snake_case__		(				self  :						Tuple			,					*lowerCAmelCase__  :						int			,					**lowerCAmelCase__  :						Optional[int]	)       ->	Optional[int]:

            '''simple docstring'''




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







       @property
       def snake_case__		(				self  :						Any	)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			self.tokenizer.model_input_names
            _UpperCamelCase							       =			self.image_processor.model_input_names
            return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names	)	)



