






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 		_snake_case  (  A__   ,    unittest.TestCase					):
							_lowercase		:    Any			     =							TextToVideoSDPipeline
							_lowercase		:    Any			     =							TEXT_TO_IMAGE_PARAMS
							_lowercase		:    Optional[Any]			     =							TEXT_TO_IMAGE_BATCH_PARAMS
							# No `output_type`.
							_lowercase		:    Optional[int]			     =							frozenset(
							    [
							        '''num_inference_steps''',
							        '''generator''',
							        '''latents''',
							        '''return_dict''',
							        '''callback''',
							        '''callback_steps''',
							    ]					)






							def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[Any]:
										torch.manual_seed(0)
										SCREAMING_SNAKE_CASE						= 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		,					)
										SCREAMING_SNAKE_CASE						= DDIMScheduler(
										    beta_start=0.0_00_85		,					beta_end=0.0_12		,					beta_schedule='scaled_linear'		,					clip_sample=A__		,					set_alpha_to_one=A__		,					)
										torch.manual_seed(0)
										SCREAMING_SNAKE_CASE						= 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)
										SCREAMING_SNAKE_CASE						= CLIPTextConfig(
										    bos_token_id=0		,					eos_token_id=2		,					hidden_size=32		,					intermediate_size=37		,					layer_norm_eps=1E-05		,					num_attention_heads=4		,					num_hidden_layers=5		,					pad_token_id=1		,					vocab_size=1000		,					hidden_act='gelu'		,					projection_dim=512		,					)
										SCREAMING_SNAKE_CASE						= CLIPTextModel(A__)
										SCREAMING_SNAKE_CASE						= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

										SCREAMING_SNAKE_CASE						= {
										    """unet""": unet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										}
										return components






							def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a=0)      ->       Optional[int]:
										if str(A__).startswith('mps'):
													SCREAMING_SNAKE_CASE						= torch.manual_seed(A__)
										else:
													SCREAMING_SNAKE_CASE						= torch.Generator(device=A__).manual_seed(A__)
										SCREAMING_SNAKE_CASE						= {
										    """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    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
										SCREAMING_SNAKE_CASE						= """cpu"""  # ensure determinism for the device-dependent torch.Generator
										SCREAMING_SNAKE_CASE						= self.get_dummy_components()
										SCREAMING_SNAKE_CASE						= TextToVideoSDPipeline(**A__)
										SCREAMING_SNAKE_CASE						= sd_pipe.to(A__)
										sd_pipe.set_progress_bar_config(disable=A__)

										SCREAMING_SNAKE_CASE						= self.get_dummy_inputs(A__)
										SCREAMING_SNAKE_CASE						= """np"""
										SCREAMING_SNAKE_CASE						= sd_pipe(**A__).frames
										SCREAMING_SNAKE_CASE						= frames[0][-3:, -3:, -1]

										assert frames[0].shape == (64, 64, 3)
										SCREAMING_SNAKE_CASE						= np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0])

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






							def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
										self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A__		,					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    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
										self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A__		,					expected_max_diff=1E-2)






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






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






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







							def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
										return super().test_progress_bar()



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






							def    SCREAMING_SNAKE_CASE__    (       self)      ->       Any:
										SCREAMING_SNAKE_CASE						= load_numpy(
										    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy')

										SCREAMING_SNAKE_CASE						= TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
										SCREAMING_SNAKE_CASE						= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
										SCREAMING_SNAKE_CASE						= pipe.to('cuda')

										SCREAMING_SNAKE_CASE						= """Spiderman is surfing"""
										SCREAMING_SNAKE_CASE						= torch.Generator(device='cpu').manual_seed(0)

										SCREAMING_SNAKE_CASE						= pipe(A__		,					generator=A__		,					num_inference_steps=25		,					output_type='pt').frames
										SCREAMING_SNAKE_CASE						= video_frames.cpu().numpy()

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







							def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
										SCREAMING_SNAKE_CASE						= load_numpy(
										    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy')

										SCREAMING_SNAKE_CASE						= TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
										SCREAMING_SNAKE_CASE						= pipe.to('cuda')

										SCREAMING_SNAKE_CASE						= """Spiderman is surfing"""
										SCREAMING_SNAKE_CASE						= torch.Generator(device='cpu').manual_seed(0)

										SCREAMING_SNAKE_CASE						= pipe(A__		,					generator=A__		,					num_inference_steps=2		,					output_type='pt').frames
										SCREAMING_SNAKE_CASE						= video_frames.cpu().numpy()

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












import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


a_		:						Optional[int]             =    '\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

a_		:						Tuple             =    '\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

a_		:						Optional[Any]             =    '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wnli\')  # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			return float((preds == labels).mean())






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= simple_accuracy(_UpperCAmelCase							,       _UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= float(fa_score(y_true=_UpperCAmelCase							,       y_pred=_UpperCAmelCase))
			return {
			    "accuracy": acc,
			    "f1": fa,
			}






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= en_sentvecs.shape[0]

			# mean centering
			SCREAMING_SNAKE_CASE						= en_sentvecs - np.mean(_UpperCAmelCase							,       axis=0)
			SCREAMING_SNAKE_CASE						= in_sentvecs - np.mean(_UpperCAmelCase							,       axis=0)

			SCREAMING_SNAKE_CASE						= cdist(_UpperCAmelCase							,       _UpperCAmelCase							,       'cosine')
			SCREAMING_SNAKE_CASE						= np.array(range(_UpperCAmelCase))
			SCREAMING_SNAKE_CASE						= sim.argsort(axis=1)[:, :10]
			SCREAMING_SNAKE_CASE						= np.any(preds == actual[:, None]							,       axis=1)
			return float(matches.mean())







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,    _KWARGS_DESCRIPTION					)
class 		_snake_case  (  datasets.Metric					):






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						if self.config_name not in [
						    "wnli",
						    "copa",
						    "sna",
						    "csqa",
						    "wstp",
						    "inltkh",
						    "bbca",
						    "cvit-mkb-clsr",
						    "iitp-mr",
						    "iitp-pr",
						    "actsa-sc",
						    "md",
						    "wiki-ner",
						]:
									raise KeyError(
									    'You should supply a configuration name selected in '
									    '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
									    '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
									    '"wiki-ner"]')
						return datasets.MetricInfo(
						    description=_DESCRIPTION		,					citation=_CITATION		,					inputs_description=_KWARGS_DESCRIPTION		,					features=datasets.Features(
						        {
						            'predictions': datasets.Value('int64')
						            if self.config_name != 'cvit-mkb-clsr'
						            else datasets.Sequence(datasets.Value('float32')),
						            'references': datasets.Value('int64')
						            if self.config_name != 'cvit-mkb-clsr'
						            else datasets.Sequence(datasets.Value('float32')),
						        })		,					codebase_urls=[]		,					reference_urls=[]		,					format='numpy' if self.config_name != 'cvit-mkb-clsr' else None		,					)







			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       List[Any]:
						if self.config_name == "cvit-mkb-clsr":
									return {"precision@10": precision_at_aa(a		,					a)}
						elif self.config_name in ["wiki-ner"]:
									return acc_and_fa(a		,					a)
						elif self.config_name in [
						    "wnli",
						    "copa",
						    "sna",
						    "csqa",
						    "wstp",
						    "inltkh",
						    "bbca",
						    "iitp-mr",
						    "iitp-pr",
						    "actsa-sc",
						    "md",
						]:
									return {"accuracy": simple_accuracy(a		,					a)}
						else:
									raise KeyError(
									    'You should supply a configuration name selected in '
									    '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
									    '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
									    '"wiki-ner"]')




