


lowerCAmelCase__  :List[Any]             =							'''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''

def 	lowerCAmelCase__			(      a__:		bytes	)  ->		bytes:


							'''simple docstring'''





							if not isinstance(a__      ,  a__	):
														_UpperCAmelCase					=      F'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
														raise TypeError(a__	)

							_UpperCAmelCase					=      ''.join(bin(a__	)[2:].zfill(8	) for byte in data	)

							_UpperCAmelCase					=      len(a__	) % 6 != 0

							if padding_needed:
														# The padding that will be added later
														_UpperCAmelCase					=      B'=' * ((6 - len(a__	) % 6) // 2)

														# Append binary_stream with arbitrary binary digits (0's by default) to make its
														# length a multiple of 6.
														binary_stream += "0" * (6 - len(a__	) % 6)
							else:
														_UpperCAmelCase					=      B''

							# Encode every 6 binary digits to their corresponding Base64 character
							return (
							    "".join(
							        B64_CHARSET[int(binary_stream[index : index + 6]      ,  2	)]
							        for index in range(0      ,  len(a__	)      ,  6	)	).encode()
							    + padding
							)

def 	lowerCAmelCase__			(      a__:		str	)  ->		bytes:


							'''simple docstring'''





							if not isinstance(a__      ,  a__	) and not isinstance(a__      ,  a__	):
														_UpperCAmelCase					=      (
														    'argument should be a bytes-like object or ASCII string, '
														    F'''not \'{encoded_data.__class__.__name__}\''''
														)
														raise TypeError(a__	)

							# In case encoded_data is a bytes-like object, make sure it contains only
							# ASCII characters so we convert it to a string object
							if isinstance(a__      ,  a__	):
														try:
																					_UpperCAmelCase					=      encoded_data.decode('utf-8'	)
														except UnicodeDecodeError:
																					raise ValueError('base64 encoded data should only contain ASCII characters'	)

							_UpperCAmelCase					=      encoded_data.count('='	)

							# Check if the encoded string contains non base64 characters
							if padding:
														assert all(
														    char in B64_CHARSET for char in encoded_data[:-padding]	), "Invalid base64 character(s) found."
							else:
														assert all(
														    char in B64_CHARSET for char in encoded_data	), "Invalid base64 character(s) found."

							# Check the padding
							assert len(a__	) % 4 == 0 and padding < 3, "Incorrect padding"

							if padding:
														# Remove padding if there is one
														_UpperCAmelCase					=      encoded_data[:-padding]

														_UpperCAmelCase					=      ''.join(
														    bin(B64_CHARSET.index(a__	)	)[2:].zfill(6	) for char in encoded_data	)[: -padding * 2]
							else:
														_UpperCAmelCase					=      ''.join(
														    bin(B64_CHARSET.index(a__	)	)[2:].zfill(6	) for char in encoded_data	)

							_UpperCAmelCase					=      [
							    int(binary_stream[index : index + 8]      ,  2	)
							    for index in range(0      ,  len(a__	)      ,  8	)
							]

							return bytes(a__	)


if __name__ == "__main__":
		import doctest

		doctest.testmod()




from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available

@dataclass
class 		__a				(    UpperCAmelCase      ):
		_a     :  Union[List[np.ndarray], torch.FloatTensor]


try:
		if not (is_transformers_available() and is_torch_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
		from .pipeline_text_to_video_synth import TextToVideoSDPipeline
		from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
		from .pipeline_text_to_video_zero import TextToVideoZeroPipeline
