

'''simple docstring'''


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()




@skip_mps
class     a			(				SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			unittest.TestCase       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    StableDiffusionPanoramaPipeline
						__UpperCAmelCase			     =    TEXT_TO_IMAGE_PARAMS
						__UpperCAmelCase			     =    TEXT_TO_IMAGE_BATCH_PARAMS
						__UpperCAmelCase			     =    TEXT_TO_IMAGE_IMAGE_PARAMS
						__UpperCAmelCase			     =    TEXT_TO_IMAGE_IMAGE_PARAMS







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								torch.manual_seed(0  )
								snake_case__						:       Tuple       						=  UNetaDConditionModel(
								    block_out_channels=(3_2, 6_4)			,			layers_per_block=1			,			sample_size=3_2			,			in_channels=4			,			out_channels=4			,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')			,			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')			,			cross_attention_dim=3_2			,			)
								snake_case__						:       List[Any]       						=  DDIMScheduler()
								torch.manual_seed(0  )
								snake_case__						:       List[str]       						=  AutoencoderKL(
								    block_out_channels=[3_2, 6_4]			,			in_channels=3			,			out_channels=3			,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']			,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']			,			latent_channels=4			,			)
								torch.manual_seed(0  )
								snake_case__						:       str       						=  CLIPTextConfig(
								    bos_token_id=0			,			eos_token_id=2			,			hidden_size=3_2			,			intermediate_size=3_7			,			layer_norm_eps=1e-05			,			num_attention_heads=4			,			num_hidden_layers=5			,			pad_token_id=1			,			vocab_size=1_0_0_0			,			)
								snake_case__						:       int       						=  CLIPTextModel(snake_case_  )
								snake_case__						:       List[str]       						=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

								snake_case__						:       List[str]       						=  {
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''safety_checker''': None,
								    '''feature_extractor''': None,
								}
								return components







						def       __magic_name__							(							self					:      int			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      List[Any]=0  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  torch.manual_seed(snake_case_  )
								snake_case__						:       List[Any]       						=  {
								    '''prompt''': '''a photo of the dolomites''',
								    '''generator''': generator,
								    # Setting height and width to None to prevent OOMs on CPU.
								    '''height''': None,
								    '''width''': None,
								    '''num_inference_steps''': 1,
								    '''guidance_scale''': 6.0,
								    '''output_type''': '''numpy''',
								}
								return inputs







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       str       						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								snake_case__						:       Optional[int]       						=  self.get_dummy_components()
								snake_case__						:       Optional[Any]       						=  StableDiffusionPanoramaPipeline(**snake_case_  )
								snake_case__						:       Tuple       						=  sd_pipe.to(snake_case_  )
								sd_pipe.set_progress_bar_config(disable=snake_case_  )

								snake_case__						:       List[Any]       						=  self.get_dummy_inputs(snake_case_  )
								snake_case__						:       Any       						=  sd_pipe(**snake_case_  ).images
								snake_case__						:       Dict       						=  image[0, -3:, -3:, -1]
								assert image.shape == (1, 6_4, 6_4, 3)

								snake_case__						:       Union[str, Any]       						=  np.array([0.6_1_8_6, 0.5_3_7_4, 0.4_9_1_5, 0.4_1_3_5, 0.4_1_1_4, 0.4_5_6_3, 0.5_1_2_8, 0.4_9_7_7, 0.4_7_5_7]  )

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







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								super().test_inference_batch_consistent(batch_sizes=[1, 2]  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								super().test_inference_batch_single_identical(batch_size=2			,			expected_max_diff=3.25e-3  )







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								snake_case__						:       Optional[Any]       						=  self.get_dummy_components()
								snake_case__						:       str       						=  StableDiffusionPanoramaPipeline(**snake_case_  )
								snake_case__						:       str       						=  sd_pipe.to(snake_case_  )
								sd_pipe.set_progress_bar_config(disable=snake_case_  )

								snake_case__						:       str       						=  self.get_dummy_inputs(snake_case_  )
								snake_case__						:       int       						=  '''french fries'''
								snake_case__						:       Any       						=  sd_pipe(**snake_case_			,			negative_prompt=snake_case_  )
								snake_case__						:       Optional[Any]       						=  output.images
								snake_case__						:       List[str]       						=  image[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)

								snake_case__						:       str       						=  np.array([0.6_1_8_7, 0.5_3_7_5, 0.4_9_1_5, 0.4_1_3_6, 0.4_1_1_4, 0.4_5_6_3, 0.5_1_2_8, 0.4_9_7_6, 0.4_7_5_7]  )

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







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								snake_case__						:       Any       						=  self.get_dummy_components()
								snake_case__						:       int       						=  StableDiffusionPanoramaPipeline(**snake_case_  )
								snake_case__						:       Dict       						=  sd_pipe.to(snake_case_  )
								sd_pipe.set_progress_bar_config(disable=snake_case_  )

								snake_case__						:       Union[str, Any]       						=  self.get_dummy_inputs(snake_case_  )
								snake_case__						:       List[Any]       						=  sd_pipe(**snake_case_			,			view_batch_size=2  )
								snake_case__						:       List[Any]       						=  output.images
								snake_case__						:       str       						=  image[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)

								snake_case__						:       Optional[Any]       						=  np.array([0.6_1_8_7, 0.5_3_7_5, 0.4_9_1_5, 0.4_1_3_6, 0.4_1_1_4, 0.4_5_6_3, 0.5_1_2_8, 0.4_9_7_6, 0.4_7_5_7]  )

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







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       int       						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								snake_case__						:       Tuple       						=  self.get_dummy_components()
								snake_case__						:       str       						=  EulerAncestralDiscreteScheduler(
								    beta_start=0.0_0_0_8_5			,			beta_end=0.0_1_2			,			beta_schedule='''scaled_linear'''  )
								snake_case__						:       str       						=  StableDiffusionPanoramaPipeline(**snake_case_  )
								snake_case__						:       List[str]       						=  sd_pipe.to(snake_case_  )
								sd_pipe.set_progress_bar_config(disable=snake_case_  )

								snake_case__						:       List[Any]       						=  self.get_dummy_inputs(snake_case_  )
								snake_case__						:       int       						=  sd_pipe(**snake_case_  ).images
								snake_case__						:       Union[str, Any]       						=  image[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)

								snake_case__						:       Dict       						=  np.array([0.4_0_2_4, 0.6_5_1_0, 0.4_9_0_1, 0.5_3_7_8, 0.5_8_1_3, 0.5_6_2_2, 0.4_7_9_5, 0.4_4_6_7, 0.4_9_5_2]  )

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







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       int       						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								snake_case__						:       List[Any]       						=  self.get_dummy_components()
								snake_case__						:       Union[str, Any]       						=  PNDMScheduler(
								    beta_start=0.0_0_0_8_5			,			beta_end=0.0_1_2			,			beta_schedule='''scaled_linear'''			,			skip_prk_steps=snake_case_  )
								snake_case__						:       List[Any]       						=  StableDiffusionPanoramaPipeline(**snake_case_  )
								snake_case__						:       Dict       						=  sd_pipe.to(snake_case_  )
								sd_pipe.set_progress_bar_config(disable=snake_case_  )

								snake_case__						:       Dict       						=  self.get_dummy_inputs(snake_case_  )
								snake_case__						:       str       						=  sd_pipe(**snake_case_  ).images
								snake_case__						:       Any       						=  image[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)

								snake_case__						:       Optional[Any]       						=  np.array([0.6_3_9_1, 0.6_2_9_1, 0.4_8_6_1, 0.5_1_3_4, 0.5_5_5_2, 0.4_5_7_8, 0.5_0_3_2, 0.5_0_2_3, 0.4_5_3_9]  )

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





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






						"""simple docstring"""




						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



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







						def       __magic_name__							(							self					:      int			,			snake_case_					:      str=0  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  torch.manual_seed(snake_case_  )
								snake_case__						:       Any       						=  {
								    '''prompt''': '''a photo of the dolomites''',
								    '''generator''': generator,
								    '''num_inference_steps''': 3,
								    '''guidance_scale''': 7.5,
								    '''output_type''': '''numpy''',
								}
								return inputs







						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  '''stabilityai/stable-diffusion-2-base'''
								snake_case__						:       Dict       						=  DDIMScheduler.from_pretrained(snake_case_			,			subfolder='''scheduler'''  )
								snake_case__						:       Tuple       						=  StableDiffusionPanoramaPipeline.from_pretrained(snake_case_			,			scheduler=snake_case_			,			safety_checker=snake_case_  )
								pipe.to(snake_case_  )
								pipe.set_progress_bar_config(disable=snake_case_  )
								pipe.enable_attention_slicing()

								snake_case__						:       Dict       						=  self.get_inputs()
								snake_case__						:       List[str]       						=  pipe(**snake_case_  ).images
								snake_case__						:       Dict       						=  image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

								snake_case__						:       List[Any]       						=  np.array(
								    [
								        0.3_6_9_6_8_3_9_2,
								        0.2_7_0_2_5_3_7_2,
								        0.3_2_4_4_6_7_6_6,
								        0.2_8_3_7_9_3_8_7,
								        0.3_6_3_6_3_2_7_4,
								        0.3_0_7_3_3_3_4_7,
								        0.2_7_1_0_0_0_2_7,
								        0.2_7_0_5_4_1_2_5,
								        0.2_5_5_3_6_0_9_6,
								    ]  )

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







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  StableDiffusionPanoramaPipeline.from_pretrained(
								    '''stabilityai/stable-diffusion-2-base'''			,			safety_checker=snake_case_  )
								snake_case__						:       Any       						=  LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.to(snake_case_  )
								pipe.set_progress_bar_config(disable=snake_case_  )
								pipe.enable_attention_slicing()

								snake_case__						:       Dict       						=  self.get_inputs()
								snake_case__						:       Union[str, Any]       						=  pipe(**snake_case_  ).images
								snake_case__						:       Optional[Any]       						=  image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

								snake_case__						:       List[str]       						=  np.array(
								    [
								        [
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								            0.0,
								        ]
								    ]  )

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







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  0

								def callback_fn(snake_case_					:      int			,			snake_case_					:      int			,			snake_case_					:      torch.FloatTensor  ) -> None:
										snake_case__						:       Tuple       						=  True
										nonlocal number_of_steps
										number_of_steps += 1
										if step == 1:
												snake_case__						:       str       						=  latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 6_4, 2_5_6)
												snake_case__						:       Dict       						=  latents[0, -3:, -3:, -1]

												snake_case__						:       List[str]       						=  np.array(
												    [
												        0.1_8_6_8_1_8_6_9,
												        0.3_3_9_0_7_8_1_6,
												        0.5_3_6_1_2_7_6,
												        0.1_4_4_3_2_8_6_5,
												        -0.0_2_8_5_6_6_1_1,
												        -0.7_3_9_4_1_1_2_3,
												        0.2_3_3_9_7_9_8_7,
												        0.4_7_3_2_2_6_8_2,
												        -0.3_7_8_2_3_1_6_4,
												    ]  )
												assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 5e-2
										elif step == 2:
												snake_case__						:       Union[str, Any]       						=  latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 6_4, 2_5_6)
												snake_case__						:       str       						=  latents[0, -3:, -3:, -1]

												snake_case__						:       Union[str, Any]       						=  np.array(
												    [
												        0.1_8_5_3_9_6_4_5,
												        0.3_3_9_8_7_2_4_8,
												        0.5_3_7_8_5_5_9,
												        0.1_4_4_3_7_1_4_2,
												        -0.0_2_4_5_5_2_6_1,
												        -0.7_3_3_8_3_1_7,
												        0.2_3_9_9_0_7_5_5,
												        0.4_7_3_5_6_2_7_2,
												        -0.3_7_8_6_5_0_5,
												    ]  )

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

								snake_case__						:       str       						=  False

								snake_case__						:       int       						=  '''stabilityai/stable-diffusion-2-base'''
								snake_case__						:       Tuple       						=  DDIMScheduler.from_pretrained(snake_case_			,			subfolder='''scheduler'''  )
								snake_case__						:       int       						=  StableDiffusionPanoramaPipeline.from_pretrained(snake_case_			,			scheduler=snake_case_			,			safety_checker=snake_case_  )
								snake_case__						:       str       						=  pipe.to(snake_case_  )
								pipe.set_progress_bar_config(disable=snake_case_  )
								pipe.enable_attention_slicing()

								snake_case__						:       Any       						=  self.get_inputs()
								pipe(**snake_case_			,			callback=snake_case_			,			callback_steps=1  )
								assert callback_fn.has_been_called
								assert number_of_steps == 3







						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



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

								snake_case__						:       Any       						=  '''stabilityai/stable-diffusion-2-base'''
								snake_case__						:       Optional[Any]       						=  DDIMScheduler.from_pretrained(snake_case_			,			subfolder='''scheduler'''  )
								snake_case__						:       Optional[Any]       						=  StableDiffusionPanoramaPipeline.from_pretrained(snake_case_			,			scheduler=snake_case_			,			safety_checker=snake_case_  )
								snake_case__						:       str       						=  pipe.to(snake_case_  )
								pipe.set_progress_bar_config(disable=snake_case_  )
								pipe.enable_attention_slicing(1  )
								pipe.enable_sequential_cpu_offload()

								snake_case__						:       Any       						=  self.get_inputs()
								snake_case__						:       int       						=  pipe(**snake_case_  )

								snake_case__						:       int       						=  torch.cuda.max_memory_allocated()
								# make sure that less than 5.2 GB is allocated
								assert mem_bytes < 5.5 * 1_0**9






'''simple docstring'''


import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs




class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						def __init__(							self					:      Dict			,			snake_case_					:      str			,			snake_case_					:      Optional[int]=None			,			snake_case_					:      List[Any]=True			,			snake_case_					:      Any=None			,			**snake_case_					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  parent
								snake_case__						:       List[Any]       						=  config_class
								snake_case__						:       Optional[int]       						=  has_text_modality
								snake_case__						:       str       						=  kwargs
								snake_case__						:       Dict       						=  common_properties







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  self.config_class(**self.inputs_dict  )
								snake_case__						:       List[Any]       						=  (
								    ['''hidden_size''', '''num_attention_heads''', '''num_hidden_layers''']
								    if self.common_properties is None
								    else self.common_properties
								)

								# Add common fields for text models
								if self.has_text_modality:
										common_properties.extend(['''vocab_size''']  )

								# Test that config has the common properties as getters
								for prop in common_properties:
										self.parent.assertTrue(hasattr(snake_case_			,			snake_case_  )			,			msg=F"""`{prop}` does not exist"""  )

								# Test that config has the common properties as setter
								for idx, name in enumerate(snake_case_  ):
										try:
												setattr(snake_case_			,			snake_case_			,			snake_case_  )
												self.parent.assertEqual(
												    getattr(snake_case_			,			snake_case_  )			,			snake_case_			,			msg=F"""`{name} value {idx} expected, but was {getattr(snake_case_			,			snake_case_  )}"""  )
										except NotImplementedError:
												# Some models might not be able to implement setters for common_properties
												# In that case, a NotImplementedError is raised
												pass

        # Test if config class can be called with Config(prop_name=..)
								for idx, name in enumerate(snake_case_  ):
										try:
												snake_case__						:       Dict       						=  self.config_class(**{name: idx}  )
												self.parent.assertEqual(
												    getattr(snake_case_			,			snake_case_  )			,			snake_case_			,			msg=F"""`{name} value {idx} expected, but was {getattr(snake_case_			,			snake_case_  )}"""  )
										except NotImplementedError:
												# Some models might not be able to implement setters for common_properties
												# In that case, a NotImplementedError is raised
												pass







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  self.config_class(**self.inputs_dict  )
								snake_case__						:       str       						=  json.loads(config.to_json_string()  )
								for key, value in self.inputs_dict.items():
										self.parent.assertEqual(obj[key]			,			snake_case_  )







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  self.config_class(**self.inputs_dict  )

								with tempfile.TemporaryDirectory() as tmpdirname:
										snake_case__						:       List[Any]       						=  os.path.join(snake_case_			,			'''config.json'''  )
										config_first.to_json_file(snake_case_  )
										snake_case__						:       Dict       						=  self.config_class.from_json_file(snake_case_  )

								self.parent.assertEqual(config_second.to_dict()			,			config_first.to_dict()  )







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       int       						=  self.config_class(**self.inputs_dict  )

								with tempfile.TemporaryDirectory() as tmpdirname:
										config_first.save_pretrained(snake_case_  )
										snake_case__						:       Optional[Any]       						=  self.config_class.from_pretrained(snake_case_  )

								self.parent.assertEqual(config_second.to_dict()			,			config_first.to_dict()  )







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       int       						=  self.config_class(**self.inputs_dict  )

								snake_case__						:       str       						=  '''test'''
								with tempfile.TemporaryDirectory() as tmpdirname:
										snake_case__						:       List[str]       						=  os.path.join(snake_case_			,			snake_case_  )
										config_first.save_pretrained(snake_case_  )
										snake_case__						:       List[str]       						=  self.config_class.from_pretrained(snake_case_			,			subfolder=snake_case_  )

								self.parent.assertEqual(config_second.to_dict()			,			config_first.to_dict()  )







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  self.config_class(**self.inputs_dict			,			num_labels=5  )
								self.parent.assertEqual(len(config.idalabel  )			,			5  )
								self.parent.assertEqual(len(config.labelaid  )			,			5  )

								snake_case__						:       List[Any]       						=  3
								self.parent.assertEqual(len(config.idalabel  )			,			3  )
								self.parent.assertEqual(len(config.labelaid  )			,			3  )







						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								if self.config_class.is_composition:
										return
								snake_case__						:       Any       						=  self.config_class()
								self.parent.assertIsNotNone(snake_case_  )







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  copy.deepcopy(snake_case_  )
								snake_case__						:       Union[str, Any]       						=  self.config_class(**snake_case_  )
								snake_case__						:       List[str]       						=  []
								for key, value in config_common_kwargs.items():
										if key == "torch_dtype":
												if not is_torch_available():
														continue
												else:
														import torch

														if config.torch_dtype != torch.floataa:
																wrong_values.append(('''torch_dtype''', config.torch_dtype, torch.floataa)  )
										elif getattr(snake_case_			,			snake_case_  ) != value:
												wrong_values.append((key, getattr(snake_case_			,			snake_case_  ), value)  )

								if len(snake_case_  ) > 0:
										snake_case__						:       Dict       						=  '''\n'''.join([F"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]  )
										raise ValueError(F"""The following keys were not properly set in the config:\n{errors}"""  )







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								self.create_and_test_config_common_properties()
								self.create_and_test_config_to_json_string()
								self.create_and_test_config_to_json_file()
								self.create_and_test_config_from_and_save_pretrained()
								self.create_and_test_config_from_and_save_pretrained_subfolder()
								self.create_and_test_config_with_num_labels()
								self.check_config_can_be_init_without_params()
								self.check_config_arguments_init()



