# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

__lowercase							 =					'''2.13.1'''

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('''3.7'''):
    raise ImportWarning(
        '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'''
    )

if version.parse(pyarrow.__version__).major < 8:
    raise ImportWarning(
        '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'''
        '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'''
    )

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

__lowercase							 =					concatenate_datasets
__lowercase							 =					DownloadConfig
__lowercase							 =					DownloadManager
__lowercase							 =					DownloadMode
__lowercase							 =					DownloadConfig
__lowercase							 =					DownloadMode
__lowercase							 =					DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager






import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


@skip_mps
class 	lowerCamelCase_     (   UpperCAmelCase_						,	unittest.TestCase ):






    '''simple docstring'''






    a__	:						str						=      TextToVideoSDPipeline
    a__	:						Union[str, Any]						=      TEXT_TO_IMAGE_PARAMS
    a__	:						Tuple						=      TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    a__	:						int						=      frozenset(
        [
            """num_inference_steps""",
            """generator""",
            """latents""",
            """return_dict""",
            """callback""",
            """callback_steps""",
        ] )







    def 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        torch.manual_seed(0)
        __UpperCamelCase     :str			  =		UNetaDConditionModel(
            block_out_channels=(32, 64, 64, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''') , up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''') , cross_attention_dim=32 , attention_head_dim=4 , )
        __UpperCamelCase     :Optional[int]			  =		DDIMScheduler(
            beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , clip_sample=__lowercase , set_alpha_to_one=__lowercase , )
        torch.manual_seed(0)
        __UpperCamelCase     :Optional[int]			  =		AutoencoderKL(
            block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , sample_size=128 , )
        torch.manual_seed(0)
        __UpperCamelCase     :Optional[int]			  =		CLIPTextConfig(
            bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_000 , hidden_act='''gelu''' , projection_dim=512 , )
        __UpperCamelCase     :Optional[Any]			  =		CLIPTextModel(__lowercase)
        __UpperCamelCase     :Optional[int]			  =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        __UpperCamelCase     :Union[str, Any]			  =		{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
        }
        return components







    def 			UpperCamelCase__   (	self , __lowercase , __lowercase=0)       ->	Optional[int]:
        if str(__lowercase).startswith('''mps'''):
            __UpperCamelCase     :List[Any]			  =		torch.manual_seed(__lowercase)
        else:
            __UpperCamelCase     :Tuple			  =		torch.Generator(device=__lowercase).manual_seed(__lowercase)
        __UpperCamelCase     :Dict			  =		{
            '''prompt''': '''A painting of a squirrel eating a burger''',
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 6.0,
            '''output_type''': '''pt''',
        }
        return inputs







    def 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        __UpperCamelCase     :int			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Optional[int]			  =		self.get_dummy_components()
        __UpperCamelCase     :Dict			  =		TextToVideoSDPipeline(**__lowercase)
        __UpperCamelCase     :Any			  =		sd_pipe.to(__lowercase)
        sd_pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase     :Optional[Any]			  =		self.get_dummy_inputs(__lowercase)
        __UpperCamelCase     :int			  =		'''np'''
        __UpperCamelCase     :List[str]			  =		sd_pipe(**__lowercase).frames
        __UpperCamelCase     :Optional[Any]			  =		frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        __UpperCamelCase     :str			  =		np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	Tuple:
        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowercase , expected_max_diff=3E-3)







    @unittest.skipIf(
        torch_device != '''cuda''' or not is_xformers_available() , reason='''XFormers attention is only available with CUDA and `xformers` installed''' , )
    def 			UpperCamelCase__   (	self)       ->	Optional[int]:
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowercase , expected_max_diff=1E-2)







    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''')
    def 			UpperCamelCase__   (	self)       ->	Union[str, Any]:
        pass







    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''')
    def 			UpperCamelCase__   (	self)       ->	Dict:
        pass







    @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.''')
    def 			UpperCamelCase__   (	self)       ->	str:
        pass







    def 			UpperCamelCase__   (	self)       ->	List[str]:
        return super().test_progress_bar()


@slow
@skip_mps
class 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :Union[str, Any]			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy''')

        __UpperCamelCase     :List[str]			  =		TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
        __UpperCamelCase     :Union[str, Any]			  =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
        __UpperCamelCase     :str			  =		pipe.to('''cuda''')

        __UpperCamelCase     :Optional[Any]			  =		'''Spiderman is surfing'''
        __UpperCamelCase     :Union[str, Any]			  =		torch.Generator(device='''cpu''').manual_seed(0)

        __UpperCamelCase     :List[Any]			  =		pipe(__lowercase , generator=__lowercase , num_inference_steps=25 , output_type='''pt''').frames
        __UpperCamelCase     :Optional[int]			  =		video_frames.cpu().numpy()

        assert np.abs(expected_video - video).mean() < 5E-2







    def 			UpperCamelCase__   (	self)       ->	int:
        __UpperCamelCase     :str			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy''')

        __UpperCamelCase     :Union[str, Any]			  =		TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
        __UpperCamelCase     :str			  =		pipe.to('''cuda''')

        __UpperCamelCase     :Union[str, Any]			  =		'''Spiderman is surfing'''
        __UpperCamelCase     :int			  =		torch.Generator(device='''cpu''').manual_seed(0)

        __UpperCamelCase     :List[Any]			  =		pipe(__lowercase , generator=__lowercase , num_inference_steps=2 , output_type='''pt''').frames
        __UpperCamelCase     :Optional[Any]			  =		video_frames.cpu().numpy()

        assert np.abs(expected_video - video).mean() < 5E-2





