'''simple docstring'''

import datasets

from .evaluate import evaluate


lowercase_     		= '''\
@article{hendrycks2021cuad,
      title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},
      author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},
      journal={arXiv preprint arXiv:2103.06268},
      year={2021}
}
'''

lowercase_     		= '''
This metric wrap the official scoring script for version 1 of the Contract
Understanding Atticus Dataset (CUAD).
Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510
commercial legal contracts that have been manually labeled to identify 41 categories of important
clauses that lawyers look for when reviewing contracts in connection with corporate transactions.
'''

lowercase_     		= '''
Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': list of possible texts for the answer, as a list of strings
        depending on a threshold on the confidence probability of each prediction.
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the CUAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
    \'aupr\': Area Under the Precision-Recall curve
    \'prec_at_80_recall\': Precision at 80% recall
    \'prec_at_90_recall\': Precision at 90% recall
Examples:
    >>> predictions = [{\'prediction_text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\'], \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]
    >>> references = [{\'answers\': {\'answer_start\': [143, 49], \'text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\']}, \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]
    >>> cuad_metric = datasets.load_metric("cuad")
    >>> results = cuad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0, \'aupr\': 0.0, \'prec_at_80_recall\': 1.0, \'prec_at_90_recall\': 1.0}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,			_KWARGS_DESCRIPTION)
class   SCREAMING_SNAKE_CASE			(						datasets.Metric):







		"""simple docstring"""






		def 		UpperCamelCase__       (   self				) ->     str:
								return datasets.MetricInfo(
								    description=_DESCRIPTION		,						citation=_CITATION		,						inputs_description=_KWARGS_DESCRIPTION		,						features=datasets.Features(
								        {
								            'predictions': {
								                'id': datasets.Value('string'				),
								                'prediction_text': datasets.features.Sequence(datasets.Value('string'				)				),
								            },
								            'references': {
								                'id': datasets.Value('string'				),
								                'answers': datasets.features.Sequence(
								                    {
								                        'text': datasets.Value('string'				),
								                        'answer_start': datasets.Value('int32'				),
								                    }				),
								            },
								        }				)		,						codebase_urls=['https://www.atticusprojectai.org/cuad']		,						reference_urls=['https://www.atticusprojectai.org/cuad']		,						)






		def 		UpperCamelCase__       (   self		,						__A		,						__A				) ->     List[Any]:
								_lowerCAmelCase										={prediction['id']: prediction['prediction_text'] for prediction in predictions}
								_lowerCAmelCase										=[
								    {
								        'paragraphs': [
								            {
								                'qas': [
								                    {
								                        'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
								                        'id': ref['id'],
								                    }
								                    for ref in references
								                ]
								            }
								        ]
								    }
								]
								_lowerCAmelCase										=evaluate(dataset=__A		,						predictions=__A				)
								return score






'''simple docstring'''

import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin
@skip_mps
class   SCREAMING_SNAKE_CASE			(						__lowercase    ,			__lowercase    ,			unittest.TestCase):







		"""simple docstring"""
		lowercase   :      List[Any]       =							IFPipeline
		lowercase   :      Tuple       =							TEXT_TO_IMAGE_PARAMS - {'width', 'height', 'latents'}
		lowercase   :      Union[str, Any]       =							TEXT_TO_IMAGE_BATCH_PARAMS
		lowercase   :      int       =							PipelineTesterMixin.required_optional_params - {'latents'}






		def 		UpperCamelCase__       (   self				) ->     str:
								return self._get_dummy_components()






		def 		UpperCamelCase__       (   self		,						__A		,						__A=0				) ->     int:
								if str(__A				).startswith('mps'				):
														_lowerCAmelCase										=torch.manual_seed(__A				)
								else:
														_lowerCAmelCase										=torch.Generator(device=__A				).manual_seed(__A				)

								_lowerCAmelCase										={
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'output_type': 'numpy',
								}

								return inputs






		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								self._test_save_load_optional_components()






		@unittest.skipIf(torch_device != 'cuda'		,						reason='float16 requires CUDA'				)
		def 		UpperCamelCase__       (   self				) ->     Tuple:
								# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
								super().test_save_load_floataa(expected_max_diff=1E-1				)






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2				)






		def 		UpperCamelCase__       (   self				) ->     str:
								self._test_save_load_local()






		def 		UpperCamelCase__       (   self				) ->     Union[str, Any]:
								self._test_inference_batch_single_identical(
								    expected_max_diff=1E-2		,						)






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

@slow
@require_torch_gpu
class   SCREAMING_SNAKE_CASE			(						unittest.TestCase):







		"""simple docstring"""






		def 		UpperCamelCase__       (   self				) ->     Optional[int]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								# if

								_lowerCAmelCase										=IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0'		,						variant='fp16'		,						torch_dtype=torch.floataa				)

								_lowerCAmelCase										=IFSuperResolutionPipeline.from_pretrained(
								    'DeepFloyd/IF-II-L-v1.0'		,						variant='fp16'		,						torch_dtype=torch.floataa		,						text_encoder=__A		,						tokenizer=__A				)

								# pre compute text embeddings and remove T5 to save memory

								pipe_a.text_encoder.to('cuda'				)

								_lowerCAmelCase						,				_lowerCAmelCase										=pipe_a.encode_prompt('anime turtle'		,						device='cuda'				)

								del pipe_a.tokenizer
								del pipe_a.text_encoder
								gc.collect()

								_lowerCAmelCase										=None
								_lowerCAmelCase										=None

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if(__A		,						__A		,						__A		,						__A				)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# img2img

								_lowerCAmelCase										=IFImgaImgPipeline(**pipe_a.components				)
								_lowerCAmelCase										=IFImgaImgSuperResolutionPipeline(**pipe_a.components				)

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if_imgaimg(__A		,						__A		,						__A		,						__A				)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# inpainting

								_lowerCAmelCase										=IFInpaintingPipeline(**pipe_a.components				)
								_lowerCAmelCase										=IFInpaintingSuperResolutionPipeline(**pipe_a.components				)

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if_inpainting(__A		,						__A		,						__A		,						__A				)






		def 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A				) ->     str:
								# pipeline 1

								_start_torch_memory_measurement()

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)
								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						num_inference_steps=2		,						generator=__A		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (64, 64, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 13 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)

								# pipeline 2

								_start_torch_memory_measurement()

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)

								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(0				)				).to(__A				)

								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						image=__A		,						generator=__A		,						num_inference_steps=2		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (256, 256, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)






		def 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A				) ->     Optional[int]:
								# pipeline 1

								_start_torch_memory_measurement()

								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(0				)				).to(__A				)

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)

								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						image=__A		,						num_inference_steps=2		,						generator=__A		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (64, 64, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)

								# pipeline 2

								_start_torch_memory_measurement()

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)

								_lowerCAmelCase										=floats_tensor((1, 3, 256, 256)		,						rng=random.Random(0				)				).to(__A				)
								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(0				)				).to(__A				)

								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						image=__A		,						original_image=__A		,						generator=__A		,						num_inference_steps=2		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (256, 256, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)






		def 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A				) ->     Dict:
								# pipeline 1

								_start_torch_memory_measurement()

								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(0				)				).to(__A				)
								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(1				)				).to(__A				)

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)
								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						image=__A		,						mask_image=__A		,						num_inference_steps=2		,						generator=__A		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (64, 64, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)

								# pipeline 2

								_start_torch_memory_measurement()

								_lowerCAmelCase										=torch.Generator(device='cpu'				).manual_seed(0				)

								_lowerCAmelCase										=floats_tensor((1, 3, 64, 64)		,						rng=random.Random(0				)				).to(__A				)
								_lowerCAmelCase										=floats_tensor((1, 3, 256, 256)		,						rng=random.Random(0				)				).to(__A				)
								_lowerCAmelCase										=floats_tensor((1, 3, 256, 256)		,						rng=random.Random(1				)				).to(__A				)

								_lowerCAmelCase										=pipe_a(
								    prompt_embeds=__A		,						negative_prompt_embeds=__A		,						image=__A		,						mask_image=__A		,						original_image=__A		,						generator=__A		,						num_inference_steps=2		,						output_type='np'		,						)

								_lowerCAmelCase										=output.images[0]

								assert image.shape == (256, 256, 3)

								_lowerCAmelCase										=torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(__A		,						__A				)



def 							UpperCamelCase__			(			):


						'''simple docstring'''






						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()





