
"""simple docstring"""




from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
						from transformers import (
						    TFAutoModel,
						    TFAutoModelForCausalLM,
						    TFAutoModelForMaskedLM,
						    TFAutoModelForPreTraining,
						    TFAutoModelForQuestionAnswering,
						    TFAutoModelForSeqaSeqLM,
						    TFAutoModelForSequenceClassification,
						    TFAutoModelForTableQuestionAnswering,
						    TFAutoModelForTokenClassification,
						    TFAutoModelWithLMHead,
						    TFBertForMaskedLM,
						    TFBertForPreTraining,
						    TFBertForQuestionAnswering,
						    TFBertForSequenceClassification,
						    TFBertModel,
						    TFFunnelBaseModel,
						    TFFunnelModel,
						    TFGPTaLMHeadModel,
						    TFRobertaForMaskedLM,
						    TFTaForConditionalGeneration,
						    TFTapasForQuestionAnswering,
						)
						from transformers.models.auto.modeling_tf_auto import (
						    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
						    TF_MODEL_FOR_MASKED_LM_MAPPING,
						    TF_MODEL_FOR_PRETRAINING_MAPPING,
						    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
						    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
						    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
						    TF_MODEL_MAPPING,
						)
						from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST





class  snake_case     (							__lowercase   ):
							UpperCAmelCase__						     =      'new-model'


if is_tf_available():





						class  snake_case     (							__lowercase   ):
													UpperCAmelCase__						     =      NewModelConfig





@require_tf
class  snake_case     (							unittest.TestCase   ):

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = '''bert-base-cased'''
									SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = '''bert-base-cased'''
									SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = TFAutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE_       ,       output_loading_info=SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE_       ,       output_loading_info=SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE_       ,       output_loading_info=SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in ["bert-base-uncased"]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in ["bert-base-uncased"]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							@slow
							@require_tensorflow_probability
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
											SCREAMING_SNAKE_CASE_						 = AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = TFAutoModelForTableQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = TFAutoModelForTableQuestionAnswering.from_pretrained(
											    SCREAMING_SNAKE_CASE_       ,       output_loading_info=SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
									self.assertEqual(model.num_parameters()       ,       1_44_10    )
									self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE_    )       ,       1_44_10    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
									self.assertEqual(model.num_parameters()       ,       1_44_10    )
									self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE_    )       ,       1_44_10    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = copy.deepcopy(model.config    )
									SCREAMING_SNAKE_CASE_						 = ['''FunnelBaseModel''']
									SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_config(SCREAMING_SNAKE_CASE_    )
									self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									with tempfile.TemporaryDirectory() as tmp_dir:
											model.save_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									try:
											AutoConfig.register('''new-model'''       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = [
											    TFAutoModel,
											    TFAutoModelForCausalLM,
											    TFAutoModelForMaskedLM,
											    TFAutoModelForPreTraining,
											    TFAutoModelForQuestionAnswering,
											    TFAutoModelForSequenceClassification,
											    TFAutoModelForTokenClassification,
											]

											for auto_class in auto_classes:
													with self.subTest(auto_class.__name__    ):
															# Wrong config class will raise an error
															with self.assertRaises(SCREAMING_SNAKE_CASE_    ):
																	auto_class.register(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
															auto_class.register(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
															# Trying to register something existing in the Transformers library will raise an error
															with self.assertRaises(SCREAMING_SNAKE_CASE_    ):
																	auto_class.register(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

															# Now that the config is registered, it can be used as any other config with the auto-API
															SCREAMING_SNAKE_CASE_						 = BertModelTester(self    ).get_config()
															SCREAMING_SNAKE_CASE_						 = NewModelConfig(**tiny_config.to_dict()    )
															SCREAMING_SNAKE_CASE_						 = auto_class.from_config(SCREAMING_SNAKE_CASE_    )
															self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

															with tempfile.TemporaryDirectory() as tmp_dir:
																	model.save_pretrained(SCREAMING_SNAKE_CASE_    )
																	SCREAMING_SNAKE_CASE_						 = auto_class.from_pretrained(SCREAMING_SNAKE_CASE_    )
																	self.assertIsInstance(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									finally:
											if "new-model" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["new-model"]
											for mapping in (
											    TF_MODEL_MAPPING,
											    TF_MODEL_FOR_PRETRAINING_MAPPING,
											    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
											    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
											    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
											    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
											    TF_MODEL_FOR_MASKED_LM_MAPPING,
											):
													if NewModelConfig in mapping._extra_content:
															del mapping._extra_content[NewModelConfig]

							def _lowercase					(self    ):

									"""simple docstring"""







									with self.assertRaisesRegex(
									    SCREAMING_SNAKE_CASE_       ,       '''bert-base is not a local folder and is not a valid model identifier'''    ):
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''bert-base'''    )

							def _lowercase					(self    ):

									"""simple docstring"""







									with self.assertRaisesRegex(
									    SCREAMING_SNAKE_CASE_       ,       R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''    ):
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_       ,       revision='''aaaaaa'''    )

							def _lowercase					(self    ):

									"""simple docstring"""







									with self.assertRaisesRegex(
									    SCREAMING_SNAKE_CASE_       ,       '''hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'''       ,       ):
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''    )

							def _lowercase					(self    ):

									"""simple docstring"""







									with self.assertRaisesRegex(SCREAMING_SNAKE_CASE_       ,       '''Use `from_pt=True` to load this model'''    ):
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''    )







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
									with RequestCounter() as counter:
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
											self.assertEqual(counter.get_request_count       ,       0    )
											self.assertEqual(counter.head_request_count       ,       1    )
											self.assertEqual(counter.other_request_count       ,       0    )

									# With a sharded checkpoint
									SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''    )
									with RequestCounter() as counter:
											SCREAMING_SNAKE_CASE_						 = TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''    )
											self.assertEqual(counter.get_request_count       ,       0    )
											self.assertEqual(counter.head_request_count       ,       1    )
											self.assertEqual(counter.other_request_count       ,       0    )

"""simple docstring"""




import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowerCAmelCase__							=				False





class  snake_case     (							unittest.TestCase   ):
							pass







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

							def _lowercase					(self    ):

									"""simple docstring"""







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

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''    )

									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt='''first prompt'''       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='''numpy'''       ,       ).images

									with tempfile.TemporaryDirectory() as tmpdirname:
											pipe.save_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = generator.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt='''first prompt'''       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='''numpy'''       ,       ).images

									assert np.abs(image - new_image    ).sum() < 1e-5, "Models don't have the same forward pass"







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = '''cyberpunk 2077'''
									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''    )
									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt=SCREAMING_SNAKE_CASE_       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=50       ,       output_type='''numpy'''       ,       ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.14_48, 0.16_19, 0.17_41, 0.10_86, 0.11_47, 0.11_28, 0.11_99, 0.11_65, 0.10_01]    )

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

									SCREAMING_SNAKE_CASE_						 = '''A painting of a squirrel eating a burger '''
									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.text_to_image(
									    prompt=SCREAMING_SNAKE_CASE_       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=50       ,       output_type='''numpy'''    ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.33_67, 0.31_69, 0.26_56, 0.38_70, 0.47_90, 0.37_96, 0.40_09, 0.48_78, 0.47_78]    )

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

									SCREAMING_SNAKE_CASE_						 = pipe.image_variation(SCREAMING_SNAKE_CASE_       ,       generator=SCREAMING_SNAKE_CASE_       ,       output_type='''numpy'''    ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.30_76, 0.31_23, 0.32_84, 0.37_82, 0.37_70, 0.38_94, 0.42_97, 0.43_31, 0.44_56]    )

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