




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class       lowercase_		(SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase   ):
						lowerCAmelCase__ 			=StableDiffusionImageVariationPipeline
						lowerCAmelCase__ 			=IMAGE_VARIATION_PARAMS
						lowerCAmelCase__ 			=IMAGE_VARIATION_BATCH_PARAMS
						lowerCAmelCase__ 			=frozenset([]   )
						# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
						lowerCAmelCase__ 			=frozenset([]   )



						def   __a				( self  :      int     ):

								"""simple docstring"""

								torch.manual_seed(0     )
								SCREAMING_SNAKE_CASE_							=       UNetaDConditionModel(
								    block_out_channels=(32, 64)				,       layers_per_block=2				,       sample_size=32				,       in_channels=4				,       out_channels=4				,       down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')				,       up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')				,       cross_attention_dim=32				,       )
								SCREAMING_SNAKE_CASE_							=       PNDMScheduler(skip_prk_steps=snake_case__     )
								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				,       )
								torch.manual_seed(0     )
								SCREAMING_SNAKE_CASE_							=       CLIPVisionConfig(
								    hidden_size=32				,       projection_dim=32				,       intermediate_size=37				,       layer_norm_eps=1e-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       image_size=32				,       patch_size=4				,       )
								SCREAMING_SNAKE_CASE_							=       CLIPVisionModelWithProjection(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       CLIPImageProcessor(crop_size=32				,       size=32     )

								SCREAMING_SNAKE_CASE_							=       {
								    'unet': unet,
								    'scheduler': scheduler,
								    'vae': vae,
								    'image_encoder': image_encoder,
								    'feature_extractor': feature_extractor,
								    'safety_checker': None,
								}
								return components



						def   __a				( self  :      Optional[int]				,       snake_case__  :      List[str]				,       snake_case__  :      str=0     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       floats_tensor((1, 3, 32, 32)				,       rng=random.Random(snake_case__     )     )
								SCREAMING_SNAKE_CASE_							=       image.cpu().permute(0				,       2				,       3				,       1     )[0]
								SCREAMING_SNAKE_CASE_							=       Image.fromarray(np.uinta(snake_case__     )     ).convert('RGB'     ).resize((32, 32)     )
								if str(snake_case__     ).startswith('mps'     ):
										SCREAMING_SNAKE_CASE_							=       torch.manual_seed(snake_case__     )
								else:
										SCREAMING_SNAKE_CASE_							=       torch.Generator(device=snake_case__     ).manual_seed(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       {
								    'image': image,
								    'generator': generator,
								    'num_inference_steps': 2,
								    'guidance_scale': 6.0,
								    'output_type': 'numpy',
								}
								return inputs



						def   __a				( self  :      Any     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       'cpu'  # ensure determinism for the device-dependent torch.Generator
								SCREAMING_SNAKE_CASE_							=       self.get_dummy_components()
								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline(**snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe.to(snake_case__     )
								sd_pipe.set_progress_bar_config(disable=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       self.get_dummy_inputs(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe(**snake_case__     ).images
								SCREAMING_SNAKE_CASE_							=       image[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)
								SCREAMING_SNAKE_CASE_							=       np.array([0.52_39, 0.57_23, 0.47_96, 0.50_49, 0.55_50, 0.46_85, 0.53_29, 0.48_91, 0.49_21]     )

								assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1e-3



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       'cpu'  # ensure determinism for the device-dependent torch.Generator
								SCREAMING_SNAKE_CASE_							=       self.get_dummy_components()
								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline(**snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe.to(snake_case__     )
								sd_pipe.set_progress_bar_config(disable=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       self.get_dummy_inputs(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       2 * [inputs['image']]
								SCREAMING_SNAKE_CASE_							=       sd_pipe(**snake_case__     )

								SCREAMING_SNAKE_CASE_							=       output.images

								SCREAMING_SNAKE_CASE_							=       image[-1, -3:, -3:, -1]

								assert image.shape == (2, 64, 64, 3)
								SCREAMING_SNAKE_CASE_							=       np.array([0.68_92, 0.56_37, 0.58_36, 0.57_71, 0.62_54, 0.64_09, 0.55_80, 0.55_69, 0.52_89]     )

								assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1e-3






						def   __a				( self  :      Optional[int]     ):

								"""simple docstring"""

								super().test_inference_batch_single_identical(expected_max_diff=3e-3     )



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



						def   __a				( self  :      str     ):

								"""simple docstring"""

								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



						def   __a				( self  :      int				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[Any]="cpu"				,       snake_case__  :      Union[str, Any]=torch.floataa				,       snake_case__  :      int=0     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       torch.Generator(device=snake_case__     ).manual_seed(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       load_image(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
								    '/stable_diffusion_imgvar/input_image_vermeer.png'     )
								SCREAMING_SNAKE_CASE_							=       np.random.RandomState(snake_case__     ).standard_normal((1, 4, 64, 64)     )
								SCREAMING_SNAKE_CASE_							=       torch.from_numpy(snake_case__     ).to(device=snake_case__				,       dtype=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       {
								    'image': init_image,
								    'latents': latents,
								    'generator': generator,
								    'num_inference_steps': 3,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline.from_pretrained(
								    'lambdalabs/sd-image-variations-diffusers'				,       safety_checker=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe.to(snake_case__     )
								sd_pipe.set_progress_bar_config(disable=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       self.get_inputs(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe(**snake_case__     ).images
								SCREAMING_SNAKE_CASE_							=       image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 5_12, 5_12, 3)
								SCREAMING_SNAKE_CASE_							=       np.array([0.8_44_91, 0.9_07_89, 0.7_57_08, 0.7_87_34, 0.8_34_85, 0.7_00_99, 0.6_69_38, 0.6_87_27, 0.6_13_79]     )
								assert np.abs(image_slice - expected_slice     ).max() < 6e-3



						def   __a				( self  :      Dict     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       0

								def callback_fn(snake_case__  :      int				,       snake_case__  :      int				,       snake_case__  :      torch.FloatTensor     ) -> None:
										SCREAMING_SNAKE_CASE_							=       True
										nonlocal number_of_steps
										number_of_steps += 1
										if step == 1:
												SCREAMING_SNAKE_CASE_							=       latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 64)
												SCREAMING_SNAKE_CASE_							=       latents[0, -3:, -3:, -1]
												SCREAMING_SNAKE_CASE_							=       np.array(
												    [-0.16_21, 0.28_37, -0.79_79, -0.12_21, -1.30_57, 0.76_81, -2.11_91, 0.04_64, 1.63_09]     )

												assert np.abs(latents_slice.flatten() - expected_slice     ).max() < 5e-2
										elif step == 2:
												SCREAMING_SNAKE_CASE_							=       latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 64)
												SCREAMING_SNAKE_CASE_							=       latents[0, -3:, -3:, -1]
												SCREAMING_SNAKE_CASE_							=       np.array([0.62_99, 1.75_00, 1.19_92, -2.15_82, -1.89_94, 0.73_34, -0.70_90, 1.01_37, 1.52_73]     )

												assert np.abs(latents_slice.flatten() - expected_slice     ).max() < 5e-2

								SCREAMING_SNAKE_CASE_							=       False

								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline.from_pretrained(
								    'fusing/sd-image-variations-diffusers'				,       safety_checker=snake_case__				,       torch_dtype=torch.floataa				,       )
								pipe.to(snake_case__     )
								pipe.set_progress_bar_config(disable=snake_case__     )
								pipe.enable_attention_slicing()

								SCREAMING_SNAKE_CASE_							=       self.get_inputs(snake_case__				,       dtype=torch.floataa     )
								pipe(**snake_case__				,       callback=snake_case__				,       callback_steps=1     )
								assert callback_fn.has_been_called
								assert number_of_steps == inputs["num_inference_steps"]






						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

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

								SCREAMING_SNAKE_CASE_							=       'fusing/sd-image-variations-diffusers'
								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline.from_pretrained(
								    snake_case__				,       safety_checker=snake_case__				,       torch_dtype=torch.floataa     )
								SCREAMING_SNAKE_CASE_							=       pipe.to(snake_case__     )
								pipe.set_progress_bar_config(disable=snake_case__     )
								pipe.enable_attention_slicing(1     )
								pipe.enable_sequential_cpu_offload()

								SCREAMING_SNAKE_CASE_							=       self.get_inputs(snake_case__				,       dtype=torch.floataa     )
								SCREAMING_SNAKE_CASE_							=       pipe(**snake_case__     )

								SCREAMING_SNAKE_CASE_							=       torch.cuda.max_memory_allocated()
								# make sure that less than 2.6 GB is allocated
								assert mem_bytes < 2.6 * 10**9



@nightly
@require_torch_gpu
class       lowercase_		(unittest.TestCase   ):



						def   __a				( self  :      Any     ):

								"""simple docstring"""

								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



						def   __a				( self  :      int				,       snake_case__  :      Tuple				,       snake_case__  :      List[Any]="cpu"				,       snake_case__  :      Optional[Any]=torch.floataa				,       snake_case__  :      List[str]=0     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       torch.Generator(device=snake_case__     ).manual_seed(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       load_image(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
								    '/stable_diffusion_imgvar/input_image_vermeer.png'     )
								SCREAMING_SNAKE_CASE_							=       np.random.RandomState(snake_case__     ).standard_normal((1, 4, 64, 64)     )
								SCREAMING_SNAKE_CASE_							=       torch.from_numpy(snake_case__     ).to(device=snake_case__				,       dtype=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       {
								    'image': init_image,
								    'latents': latents,
								    'generator': generator,
								    'num_inference_steps': 50,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs



						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'     )
								sd_pipe.to(snake_case__     )
								sd_pipe.set_progress_bar_config(disable=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       self.get_inputs(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       sd_pipe(**snake_case__     ).images[0]

								SCREAMING_SNAKE_CASE_							=       load_numpy(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
								    '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'     )
								SCREAMING_SNAKE_CASE_							=       np.abs(expected_image - image     ).max()
								assert max_diff < 1e-3






						def   __a				( self  :      Optional[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'     )
								SCREAMING_SNAKE_CASE_							=       DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config     )
								sd_pipe.to(snake_case__     )
								sd_pipe.set_progress_bar_config(disable=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       self.get_inputs(snake_case__     )
								SCREAMING_SNAKE_CASE_							=       25
								SCREAMING_SNAKE_CASE_							=       sd_pipe(**snake_case__     ).images[0]

								SCREAMING_SNAKE_CASE_							=       load_numpy(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
								    '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'     )
								SCREAMING_SNAKE_CASE_							=       np.abs(expected_image - image     ).max()
								assert max_diff < 1e-3





import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    SummarizationPipeline,
    TFPreTrainedModel,
    pipeline,
)
from transformers.testing_utils import get_gpu_count, is_pipeline_test, require_tf, require_torch, slow, torch_device
from transformers.tokenization_utils import TruncationStrategy

from .test_pipelines_common import ANY


SCREAMING_SNAKE_CASE:    Optional[Any]											=   -1 if torch_device == '''cpu''' else 0



@is_pipeline_test
class       lowercase_		(unittest.TestCase   ):
						lowerCAmelCase__ 			=MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
						lowerCAmelCase__ 			=TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



						def   __a				( self  :      Optional[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      Tuple				,       snake_case__  :      Optional[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       SummarizationPipeline(model=snake_case__				,       tokenizer=snake_case__     )
								return summarizer, ["(CNN)The Palestinian Authority officially became", "Some other text"]



						def   __a				( self  :      Tuple				,       snake_case__  :      str				,       snake_case__  :      Union[str, Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       summarizer.model

								SCREAMING_SNAKE_CASE_							=       summarizer('(CNN)The Palestinian Authority officially became'     )
								self.assertEqual(snake_case__				,       [{'summary_text': ANY(snake_case__     )}]     )

								SCREAMING_SNAKE_CASE_							=       summarizer(
								    '(CNN)The Palestinian Authority officially became '				,       num_beams=2				,       min_length=2				,       max_length=5				,       )
								self.assertEqual(snake_case__				,       [{'summary_text': ANY(snake_case__     )}]     )

								# Some models (Switch Transformers, LED, T5, LongT5, etc) can handle long sequences.
								SCREAMING_SNAKE_CASE_							=       [
								    'SwitchTransformersConfig',
								    'T5Config',
								    'LongT5Config',
								    'LEDConfig',
								    'PegasusXConfig',
								    'FSMTConfig',
								    'M2M100Config',
								    'ProphetNetConfig',  # positional embeddings up to a fixed maximum size (otherwise clamping the values)
								]
								if model.config.__class__.__name__ not in model_can_handle_longer_seq:
										# Too long and exception is expected.
										# For TF models, if the weights are initialized in GPU context, we won't get expected index error from
										# the embedding layer.
										if not (
										    isinstance(snake_case__				,       snake_case__     )
										    and get_gpu_count() > 0
										    and len(summarizer.model.trainable_weights     ) > 0
										):
												with self.assertRaises(snake_case__     ):
														SCREAMING_SNAKE_CASE_							=       summarizer('This ' * 10_00     )
								SCREAMING_SNAKE_CASE_							=       summarizer('This ' * 10_00				,       truncation=TruncationStrategy.ONLY_FIRST     )



						@require_torch
						def   __a				( self  :      Dict     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       pipeline(task='summarization'				,       model='sshleifer/tiny-mbart'				,       framework='pt'     )
								SCREAMING_SNAKE_CASE_							=       summarizer('This is a small test'     )
								self.assertEqual(
								    snake_case__				,       [
								        {
								            'summary_text': 'เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป'
								        }
								    ]				,       )



						@require_tf
						def   __a				( self  :      Any     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       pipeline(task='summarization'				,       model='sshleifer/tiny-mbart'				,       framework='tf'     )
								SCREAMING_SNAKE_CASE_							=       summarizer('This is a small test'     )
								self.assertEqual(
								    snake_case__				,       [
								        {
								            'summary_text': 'เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป'
								        }
								    ]				,       )






						@require_torch
						@slow
						def   __a				( self  :      Any     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       pipeline(task='summarization'				,       device=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       (
								    ' (CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on'
								    ' Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The'
								    ' formal accession was marked with a ceremony at The Hague, in the Netherlands, where the court is based.'
								    ' The Palestinians signed the ICC\'s founding Rome Statute in January, when they also accepted its'
								    ' jurisdiction over alleged crimes committed "in the occupied Palestinian territory, including East'
								    ' Jerusalem, since June 13, 2014." Later that month, the ICC opened a preliminary examination into the'
								    ' situation in Palestinian territories, paving the way for possible war crimes investigations against'
								    ' Israelis. As members of the court, Palestinians may be subject to counter-charges as well. Israel and'
								    ' the United States, neither of which is an ICC member, opposed the Palestinians\' efforts to join the'
								    ' body. But Palestinian Foreign Minister Riad al-Malki, speaking at Wednesday\'s ceremony, said it was a'
								    ' move toward greater justice. "As Palestine formally becomes a State Party to the Rome Statute today, the'
								    ' world is also a step closer to ending a long era of impunity and injustice," he said, according to an'
								    ' ICC news release. "Indeed, today brings us closer to our shared goals of justice and peace." Judge'
								    ' Kuniko Ozaki, a vice president of the ICC, said acceding to the treaty was just the first step for the'
								    ' Palestinians. "As the Rome Statute today enters into force for the State of Palestine, Palestine'
								    ' acquires all the rights as well as responsibilities that come with being a State Party to the Statute.'
								    ' These are substantive commitments, which cannot be taken lightly," she said. Rights group Human Rights'
								    ' Watch welcomed the development. "Governments seeking to penalize Palestine for joining the ICC should'
								    ' immediately end their pressure, and countries that support universal acceptance of the court\'s treaty'
								    ' should speak out to welcome its membership," said Balkees Jarrah, international justice counsel for the'
								    ' group. \"What\'s objectionable is the attempts to undermine international justice, not Palestine\'s'
								    ' decision to join a treaty to which over 100 countries around the world are members." In January, when'
								    ' the preliminary ICC examination was opened, Israeli Prime Minister Benjamin Netanyahu described it as an'
								    ' outrage, saying the court was overstepping its boundaries. The United States also said it "strongly"'
								    ' disagreed with the court\'s decision. \"As we have said repeatedly, we do not believe that Palestine is a'
								    ' state and therefore we do not believe that it is eligible to join the ICC," the State Department said in'
								    ' a statement. It urged the warring sides to resolve their differences through direct negotiations. "We'
								    ' will continue to oppose actions against Israel at the ICC as counterproductive to the cause of peace,"'
								    ' it said. But the ICC begs to differ with the definition of a state for its purposes and refers to the'
								    ' territories as "Palestine." While a preliminary examination is not a formal investigation, it allows the'
								    ' court to review evidence and determine whether to investigate suspects on both sides. Prosecutor Fatou'
								    ' Bensouda said her office would "conduct its analysis in full independence and impartiality." The war'
								    ' between Israel and Hamas militants in Gaza last summer left more than 2,000 people dead. The inquiry'
								    ' will include alleged war crimes committed since June. The International Criminal Court was set up in'
								    ' 2002 to prosecute genocide, crimes against humanity and war crimes. CNN\'s Vasco Cotovio, Kareem Khadder'
								    ' and Faith Karimi contributed to this report.'
								)
								SCREAMING_SNAKE_CASE_							=       (
								    ' The Palestinian Authority becomes the 123rd member of the International Criminal Court . The move gives'
								    ' the court jurisdiction over alleged crimes in Palestinian territories . Israel and the United States'
								    ' opposed the Palestinians\' efforts to join the court . Rights group Human Rights Watch welcomes the move,'
								    ' says governments seeking to penalize Palestine should end pressure .'
								)
								SCREAMING_SNAKE_CASE_							=       summarizer(snake_case__     )
								self.assertEqual(result[0]['summary_text']				,       snake_case__     )