


'''simple docstring'''
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
					import PIL


lowerCAmelCase   : Tuple             =				logging.get_logger(__name__)




def 	_A  (       A							)  ->				List[List[ImageInput]]:
	if isinstance(A							,(list, tuple)							) and isinstance(videos[0]							,(list, tuple)							) and is_valid_image(videos[0][0]							):
		return videos

	elif isinstance(A							,(list, tuple)							) and is_valid_image(videos[0]							):
		return [videos]

	elif is_valid_image(A							):
		return [[videos]]

	raise ValueError(F'''Could not make batched video from {videos}'''							)






class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE):


				'''simple docstring'''


				_snake_case						       =				['''pixel_values''']

				def __init__(     self							,      a_ = True							,      a_ = None							,      a_ = PILImageResampling.BILINEAR							,      a_ = True							,      a_ = None							,      a_ = True							,      a_ = 1 / 2_5_5							,      a_ = True							,      a_ = None							,      a_ = None							,      **a_							,      )    ->  None:
					super().__init__(**a_							)
					lowercase						:		Any   					=		size if size is not None else {"shortest_edge": 2_2_4}
					lowercase						:		List[str]   					=		get_size_dict(a_							,      default_to_square=a_							)
					lowercase						:		Optional[int]   					=		crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
					lowercase						:		List[str]   					=		get_size_dict(a_							,      param_name="crop_size"							)

					lowercase						:		int   					=		do_resize
					lowercase						:		int   					=		size
					lowercase						:		Tuple   					=		do_center_crop
					lowercase						:		Dict   					=		crop_size
					lowercase						:		List[str]   					=		resample
					lowercase						:		Dict   					=		do_rescale
					lowercase						:		Optional[int]   					=		rescale_factor
					lowercase						:		Optional[int]   					=		do_normalize
					lowercase						:		Tuple   					=		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
					lowercase						:		Tuple   					=		image_std if image_std is not None else IMAGENET_STANDARD_STD

				def 	a__		(     self							,      a_							,      a_							,      a_ = PILImageResampling.BILINEAR							,      a_ = None							,      **a_							,      )    ->  np.ndarray:
					lowercase						:		Dict   					=		get_size_dict(a_							,      default_to_square=a_							)
					if "shortest_edge" in size:
						lowercase						:		int   					=		get_resize_output_image_size(a_							,      size["shortest_edge"]							,      default_to_square=a_							)
					elif "height" in size and "width" in size:
						lowercase						:		Union[str, Any]   					=		(size["height"], size["width"])
					else:
						raise ValueError(F'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'''							)
					return resize(a_							,      size=a_							,      resample=a_							,      data_format=a_							,      **a_							)

				def 	a__		(     self							,      a_							,      a_							,      a_ = None							,      **a_							,      )    ->  np.ndarray:
					lowercase						:		Optional[int]   					=		get_size_dict(a_							)
					if "height" not in size or "width" not in size:
						raise ValueError(F'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}'''							)
					return center_crop(a_							,      size=(size["height"], size["width"])							,      data_format=a_							,      **a_							)

				def 	a__		(     self							,      a_							,      a_							,      a_ = None							,      **a_							,      )    ->  Optional[Any]:
					return rescale(a_							,      scale=a_							,      data_format=a_							,      **a_							)

				def 	a__		(     self							,      a_							,      a_							,      a_							,      a_ = None							,      **a_							,      )    ->  np.ndarray:
					return normalize(a_							,      mean=a_							,      std=a_							,      data_format=a_							,      **a_							)

				def 	a__		(     self							,      a_							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = ChannelDimension.FIRST							,      )    ->  np.ndarray:
					if do_resize and size is None or resample is None:
						raise ValueError("Size and resample must be specified if do_resize is True."							)

					if do_center_crop and crop_size is None:
						raise ValueError("Crop size must be specified if do_center_crop is True."							)

					if do_rescale and rescale_factor is None:
						raise ValueError("Rescale factor must be specified if do_rescale is True."							)

					if do_normalize and (image_mean is None or image_std is None):
						raise ValueError("Image mean and std must be specified if do_normalize is True."							)

					# All transformations expect numpy arrays.
					lowercase						:		Union[str, Any]   					=		to_numpy_array(a_							)

					if do_resize:
						lowercase						:		str   					=		self.resize(image=a_							,      size=a_							,      resample=a_							)

					if do_center_crop:
						lowercase						:		Dict   					=		self.center_crop(a_							,      size=a_							)

					if do_rescale:
						lowercase						:		Tuple   					=		self.rescale(image=a_							,      scale=a_							)

					if do_normalize:
						lowercase						:		str   					=		self.normalize(image=a_							,      mean=a_							,      std=a_							)

					lowercase						:		Union[str, Any]   					=		to_channel_dimension_format(a_							,      a_							)
					return image


				def 	a__		(     self							,      a_							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = None							,      a_ = ChannelDimension.FIRST							,      **a_							,      )    ->  PIL.Image.Image:
					lowercase						:		int   					=		do_resize if do_resize is not None else self.do_resize
					lowercase						:		List[str]   					=		resample if resample is not None else self.resample
					lowercase						:		Tuple   					=		do_center_crop if do_center_crop is not None else self.do_center_crop
					lowercase						:		int   					=		do_rescale if do_rescale is not None else self.do_rescale
					lowercase						:		Union[str, Any]   					=		rescale_factor if rescale_factor is not None else self.rescale_factor
					lowercase						:		str   					=		do_normalize if do_normalize is not None else self.do_normalize
					lowercase						:		Dict   					=		image_mean if image_mean is not None else self.image_mean
					lowercase						:		List[Any]   					=		image_std if image_std is not None else self.image_std

					lowercase						:		List[Any]   					=		size if size is not None else self.size
					lowercase						:		Optional[int]   					=		get_size_dict(a_							,      default_to_square=a_							)
					lowercase						:		Optional[int]   					=		crop_size if crop_size is not None else self.crop_size
					lowercase						:		List[str]   					=		get_size_dict(a_							,      param_name="crop_size"							)

					if not valid_images(a_							):
						raise ValueError(
						    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
						    "torch.Tensor, tf.Tensor or jax.ndarray."							)

					lowercase						:		str   					=		make_batched(a_							)

					lowercase						:		List[str]   					=		[
					    [
					        self._preprocess_image(
					            image=a_							,      do_resize=a_							,      size=a_							,      resample=a_							,      do_center_crop=a_							,      crop_size=a_							,      do_rescale=a_							,      rescale_factor=a_							,      do_normalize=a_							,      image_mean=a_							,      image_std=a_							,      data_format=a_							,      )
					        for img in video
					    ]
					    for video in videos
					]

					lowercase						:		Tuple   					=		{"pixel_values": videos}
					return BatchFeature(data=a_							,      tensor_type=a_							)






'''simple docstring'''
from manim import *




class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE):


				'''simple docstring'''


				def 	a__		(     self							)    ->  List[str]:
					lowercase						:		List[Any]   					=		Rectangle(height=0.5							,      width=0.5							)
					lowercase						:		str   					=		Rectangle(height=0.25							,      width=0.25							)
					lowercase						:		Union[str, Any]   					=		Rectangle(height=0.46							,      width=0.46							).set_stroke(width=0							)

					lowercase						:		List[str]   					=		[mem.copy() for i in range(6							)]
					lowercase						:		Any   					=		[mem.copy() for i in range(6							)]
					lowercase						:		List[str]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		List[Any]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		List[Any]   					=		VGroup(a_							,      a_							).arrange(a_							,      buff=0							)
					lowercase						:		Union[str, Any]   					=		Text("CPU"							,      font_size=2_4							)
					lowercase						:		List[Any]   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					cpu.move_to([-2.5, -0.5, 0]							)
					self.add(a_							)

					lowercase						:		List[Any]   					=		[mem.copy() for i in range(4							)]
					lowercase						:		Union[str, Any]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Dict   					=		Text("GPU"							,      font_size=2_4							)
					lowercase						:		Tuple   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					gpu.move_to([-1, -1, 0]							)
					self.add(a_							)

					lowercase						:		Tuple   					=		[mem.copy() for i in range(6							)]
					lowercase						:		Optional[int]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)

					lowercase						:		Any   					=		Text("Model"							,      font_size=2_4							)
					lowercase						:		str   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					model.move_to([3, -1.0, 0]							)
					self.add(a_							)

					lowercase						:		Dict   					=		[]
					lowercase						:		Tuple   					=		[]
					lowercase						:		List[Any]   					=		[]

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

						lowercase						:		Tuple   					=		Rectangle(height=0.46 / 4							,      width=0.46 / 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.02							,      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_							)

					lowercase						:		Any   					=		[mem.copy() for i in range(6							)]
					lowercase						:		Dict   					=		VGroup(*a_							).arrange(a_							,      buff=0							)

					lowercase						:		List[str]   					=		Text("Loaded Checkpoint"							,      font_size=2_4							)
					lowercase						:		Optional[Any]   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					checkpoint.move_to([3, 0.5, 0]							)

					self.add(a_							)

					lowercase						:		Any   					=		[]
					lowercase						:		int   					=		[]

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

						lowercase						:		Optional[Any]   					=		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_							)

					lowercase						:		Optional[Any]   					=		Square(side_length=2.2							)
					key.move_to([-5, 2, 0]							)

					lowercase						:		str   					=		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_							)

					lowercase						:		Any   					=		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_							)

					lowercase						:		List[Any]   					=		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]							)

					lowercase						:		Any   					=		[meta_mem.copy() for i in range(6							)]
					lowercase						:		Dict   					=		[meta_mem.copy() for i in range(6							)]
					lowercase						:		Union[str, Any]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Dict   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Any   					=		VGroup(a_							,      a_							).arrange(a_							,      buff=0							)
					lowercase						:		Optional[Any]   					=		Text("Disk"							,      font_size=2_4							)
					lowercase						:		List[str]   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					disk.move_to([-4.0, -1.25, 0]							)
					self.play(Write(a_							,      run_time=3							)							,      Write(a_							,      run_time=1							)							,      Create(a_							,      run_time=1							)							)

					lowercase						:		Optional[Any]   					=		[]
					for i, rect in enumerate(a_							):
						lowercase						:		int   					=		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_							)							)

					lowercase						:		List[Any]   					=		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()


