





# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()

class      A_	(a_					,							a_					,							a_					,							unittest.TestCase      ):
	UpperCAmelCase__ =      StableDiffusionControlNetInpaintPipeline
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	UpperCAmelCase__ =      frozenset({'''control_image'''}      )  # skip `image` and `mask` for now, only test for control_image
	UpperCAmelCase__ =      TEXT_TO_IMAGE_IMAGE_PARAMS
	def 					_lowercase    (   self		):






				'''simple docstring'''







				torch.manual_seed(0		)
				UpperCAmelCase       		=    UNetaDConditionModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, sample_size=3_2							, in_channels=9							, out_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							, cross_attention_dim=3_2							, )
				torch.manual_seed(0		)
				UpperCAmelCase       		=    ControlNetModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, in_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, cross_attention_dim=3_2							, conditioning_embedding_out_channels=(1_6, 3_2)							, )
				torch.manual_seed(0		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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							, )
				UpperCAmelCase       		=    CLIPTextModel(_A		)
				UpperCAmelCase       		=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

				UpperCAmelCase       		=    {
				    '''unet''': unet,
				    '''controlnet''': controlnet,
				    '''scheduler''': scheduler,
				    '''vae''': vae,
				    '''text_encoder''': text_encoder,
				    '''tokenizer''': tokenizer,
				    '''safety_checker''': None,
				    '''feature_extractor''': None,
				}
				return components
	def 					_lowercase    (   self							, _A							, _A=0		):






				'''simple docstring'''







				if str(_A		).startswith('''mps'''		):
							UpperCAmelCase       		=    torch.manual_seed(_A		)
				else:
							UpperCAmelCase       		=    torch.Generator(device=_A		).manual_seed(_A		)

				UpperCAmelCase       		=    2
				UpperCAmelCase       		=    randn_tensor(
				    (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)							, generator=_A							, device=torch.device(_A		)							, )
				UpperCAmelCase       		=    floats_tensor((1, 3, 3_2, 3_2)							, rng=random.Random(_A		)		).to(_A		)
				UpperCAmelCase       		=    init_image.cpu().permute(0							, 2							, 3							, 1		)[0]

				UpperCAmelCase       		=    Image.fromarray(np.uinta(_A		)		).convert('''RGB'''		).resize((6_4, 6_4)		)
				UpperCAmelCase       		=    Image.fromarray(np.uinta(init_image + 4		)		).convert('''RGB'''		).resize((6_4, 6_4)		)

				UpperCAmelCase       		=    {
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''generator''': generator,
				    '''num_inference_steps''': 2,
				    '''guidance_scale''': 6.0,
				    '''output_type''': '''numpy''',
				    '''image''': image,
				    '''mask_image''': mask_image,
				    '''control_image''': control_image,
				}

				return inputs
	def 					_lowercase    (   self		):






				'''simple docstring'''







				return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3		)
	@unittest.skipIf(
	    torch_device != '''cuda''' or not is_xformers_available()							, reason='''XFormers attention is only available with CUDA and `xformers` installed'''							, )
	def 					_lowercase    (   self		):






				'''simple docstring'''







				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				self._test_inference_batch_single_identical(expected_max_diff=2E-3		)

class      A_	(a_      ):
	UpperCAmelCase__ =      StableDiffusionControlNetInpaintPipeline
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	UpperCAmelCase__ =      frozenset([]      )
	def 					_lowercase    (   self		):






				'''simple docstring'''







				torch.manual_seed(0		)
				UpperCAmelCase       		=    UNetaDConditionModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, 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							, )
				torch.manual_seed(0		)
				UpperCAmelCase       		=    ControlNetModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, in_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, cross_attention_dim=3_2							, conditioning_embedding_out_channels=(1_6, 3_2)							, )
				torch.manual_seed(0		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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							, )
				UpperCAmelCase       		=    CLIPTextModel(_A		)
				UpperCAmelCase       		=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

				UpperCAmelCase       		=    {
				    '''unet''': unet,
				    '''controlnet''': controlnet,
				    '''scheduler''': scheduler,
				    '''vae''': vae,
				    '''text_encoder''': text_encoder,
				    '''tokenizer''': tokenizer,
				    '''safety_checker''': None,
				    '''feature_extractor''': None,
				}
				return components

class      A_	(a_					,							a_					,							unittest.TestCase      ):
	UpperCAmelCase__ =      StableDiffusionControlNetInpaintPipeline
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	UpperCAmelCase__ =      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	def 					_lowercase    (   self		):






				'''simple docstring'''







				torch.manual_seed(0		)
				UpperCAmelCase       		=    UNetaDConditionModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, sample_size=3_2							, in_channels=9							, out_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							, cross_attention_dim=3_2							, )
				torch.manual_seed(0		)

				def init_weights(_A		):
							if isinstance(_A							, torch.nn.Convad		):
										torch.nn.init.normal(m.weight		)
										m.bias.data.fill_(1.0		)

				UpperCAmelCase       		=    ControlNetModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, in_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, cross_attention_dim=3_2							, conditioning_embedding_out_channels=(1_6, 3_2)							, )
				controlneta.controlnet_down_blocks.apply(_A		)

				torch.manual_seed(0		)
				UpperCAmelCase       		=    ControlNetModel(
				    block_out_channels=(3_2, 6_4)							, layers_per_block=2							, in_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, cross_attention_dim=3_2							, conditioning_embedding_out_channels=(1_6, 3_2)							, )
				controlneta.controlnet_down_blocks.apply(_A		)

				torch.manual_seed(0		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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		)
				UpperCAmelCase       		=    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							, )
				UpperCAmelCase       		=    CLIPTextModel(_A		)
				UpperCAmelCase       		=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

				UpperCAmelCase       		=    MultiControlNetModel([controlneta, controlneta]		)

				UpperCAmelCase       		=    {
				    '''unet''': unet,
				    '''controlnet''': controlnet,
				    '''scheduler''': scheduler,
				    '''vae''': vae,
				    '''text_encoder''': text_encoder,
				    '''tokenizer''': tokenizer,
				    '''safety_checker''': None,
				    '''feature_extractor''': None,
				}
				return components
	def 					_lowercase    (   self							, _A							, _A=0		):






				'''simple docstring'''







				if str(_A		).startswith('''mps'''		):
							UpperCAmelCase       		=    torch.manual_seed(_A		)
				else:
							UpperCAmelCase       		=    torch.Generator(device=_A		).manual_seed(_A		)

				UpperCAmelCase       		=    2

				UpperCAmelCase       		=    [
				    randn_tensor(
				        (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)							, generator=_A							, device=torch.device(_A		)							, ),
				    randn_tensor(
				        (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)							, generator=_A							, device=torch.device(_A		)							, ),
				]
				UpperCAmelCase       		=    floats_tensor((1, 3, 3_2, 3_2)							, rng=random.Random(_A		)		).to(_A		)
				UpperCAmelCase       		=    init_image.cpu().permute(0							, 2							, 3							, 1		)[0]

				UpperCAmelCase       		=    Image.fromarray(np.uinta(_A		)		).convert('''RGB'''		).resize((6_4, 6_4)		)
				UpperCAmelCase       		=    Image.fromarray(np.uinta(init_image + 4		)		).convert('''RGB'''		).resize((6_4, 6_4)		)

				UpperCAmelCase       		=    {
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''generator''': generator,
				    '''num_inference_steps''': 2,
				    '''guidance_scale''': 6.0,
				    '''output_type''': '''numpy''',
				    '''image''': image,
				    '''mask_image''': mask_image,
				    '''control_image''': control_image,
				}

				return inputs
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    self.get_dummy_components()
				UpperCAmelCase       		=    self.pipeline_class(**_A		)
				pipe.to(_A		)

				UpperCAmelCase       		=    10.0
				UpperCAmelCase       		=    4

				UpperCAmelCase       		=    self.get_dummy_inputs(_A		)
				UpperCAmelCase       		=    steps
				UpperCAmelCase       		=    scale
				UpperCAmelCase       		=    pipe(**_A		)[0]

				UpperCAmelCase       		=    self.get_dummy_inputs(_A		)
				UpperCAmelCase       		=    steps
				UpperCAmelCase       		=    scale
				UpperCAmelCase       		=    pipe(**_A							, control_guidance_start=0.1							, control_guidance_end=0.2		)[0]

				UpperCAmelCase       		=    self.get_dummy_inputs(_A		)
				UpperCAmelCase       		=    steps
				UpperCAmelCase       		=    scale
				UpperCAmelCase       		=    pipe(**_A							, control_guidance_start=[0.1, 0.3]							, control_guidance_end=[0.2, 0.7]		)[0]

				UpperCAmelCase       		=    self.get_dummy_inputs(_A		)
				UpperCAmelCase       		=    steps
				UpperCAmelCase       		=    scale
				UpperCAmelCase       		=    pipe(**_A							, control_guidance_start=0.4							, control_guidance_end=[0.5, 0.8]		)[0]

				# make sure that all outputs are different
				assert np.sum(np.abs(output_a - output_a		)		) > 1E-3
				assert np.sum(np.abs(output_a - output_a		)		) > 1E-3
				assert np.sum(np.abs(output_a - output_a		)		) > 1E-3
	def 					_lowercase    (   self		):






				'''simple docstring'''







				return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3		)
	@unittest.skipIf(
	    torch_device != '''cuda''' or not is_xformers_available()							, reason='''XFormers attention is only available with CUDA and `xformers` installed'''							, )
	def 					_lowercase    (   self		):






				'''simple docstring'''







				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				self._test_inference_batch_single_identical(expected_max_diff=2E-3		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    self.get_dummy_components()
				UpperCAmelCase       		=    self.pipeline_class(**_A		)
				pipe.to(_A		)
				pipe.set_progress_bar_config(disable=_A		)
				with tempfile.TemporaryDirectory() as tmpdir:
							try:
										# save_pretrained is not implemented for Multi-ControlNet
										pipe.save_pretrained(_A		)
							except NotImplementedError:
										pass

@slow
@require_torch_gpu
class      A_	(unittest.TestCase      ):
	def 					_lowercase    (   self		):






				'''simple docstring'''







				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''		)

				UpperCAmelCase       		=    StableDiffusionControlNetInpaintPipeline.from_pretrained(
				    '''runwayml/stable-diffusion-inpainting'''							, safety_checker=_A							, controlnet=_A		)
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=_A		)

				UpperCAmelCase       		=    torch.Generator(device='''cpu'''		).manual_seed(0		)
				UpperCAmelCase       		=    load_image(
				    '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''		).resize((5_1_2, 5_1_2)		)

				UpperCAmelCase       		=    load_image(
				    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
				    '''/stable_diffusion_inpaint/input_bench_mask.png'''		).resize((5_1_2, 5_1_2)		)

				UpperCAmelCase       		=    '''pitch black hole'''

				UpperCAmelCase       		=    load_image(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''		).resize((5_1_2, 5_1_2)		)

				UpperCAmelCase       		=    pipe(
				    _A							, image=_A							, mask_image=_A							, control_image=_A							, generator=_A							, output_type='''np'''							, num_inference_steps=3							, )

				UpperCAmelCase       		=    output.images[0]

				assert image.shape == (5_1_2, 5_1_2, 3)

				UpperCAmelCase       		=    load_numpy(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy'''		)

				assert np.abs(expected_image - image		).max() < 9E-2







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''		)

				UpperCAmelCase       		=    StableDiffusionControlNetInpaintPipeline.from_pretrained(
				    '''runwayml/stable-diffusion-v1-5'''							, safety_checker=_A							, controlnet=_A		)
				UpperCAmelCase       		=    DDIMScheduler.from_config(pipe.scheduler.config		)
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=_A		)

				UpperCAmelCase       		=    torch.Generator(device='''cpu'''		).manual_seed(3_3		)

				UpperCAmelCase       		=    load_image(
				    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'''		)
				UpperCAmelCase       		=    init_image.resize((5_1_2, 5_1_2)		)

				UpperCAmelCase       		=    load_image(
				    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'''		)
				UpperCAmelCase       		=    mask_image.resize((5_1_2, 5_1_2)		)

				UpperCAmelCase       		=    '''a handsome man with ray-ban sunglasses'''

				def make_inpaint_condition(_A							, _A		):
							UpperCAmelCase       		=    np.array(image.convert('''RGB'''		)		).astype(np.floataa		) / 2_55.0
							UpperCAmelCase       		=    np.array(image_mask.convert('''L'''		)		).astype(np.floataa		) / 2_55.0

							assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
							UpperCAmelCase       		=    -1.0  # set as masked pixel
							UpperCAmelCase       		=    np.expand_dims(_A							, 0		).transpose(0							, 3							, 1							, 2		)
							UpperCAmelCase       		=    torch.from_numpy(_A		)
							return image

				UpperCAmelCase       		=    make_inpaint_condition(_A							, _A		)

				UpperCAmelCase       		=    pipe(
				    _A							, image=_A							, mask_image=_A							, control_image=_A							, guidance_scale=9.0							, eta=1.0							, generator=_A							, num_inference_steps=2_0							, output_type='''np'''							, )
				UpperCAmelCase       		=    output.images[0]

				assert image.shape == (5_1_2, 5_1_2, 3)

				UpperCAmelCase       		=    load_numpy(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy'''		)

				assert np.abs(expected_image - image		).max() < 9E-2










import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard

class      A_	(unittest.TestCase      ):
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    {
				    '''model_details''': {
				        '''Organization''': '''testing''',
				        '''Model date''': '''today''',
				        '''Model version''': '''v2.1, Developed by Test Corp in 2019.''',
				        '''Architecture''': '''Convolutional Neural Network.''',
				    },
				    '''metrics''': '''BLEU and ROUGE-1''',
				    '''evaluation_data''': {
				        '''Datasets''': {'''BLEU''': '''My-great-dataset-v1''', '''ROUGE-1''': '''My-short-dataset-v2.1'''},
				        '''Preprocessing''': '''See details on https://arxiv.org/pdf/1810.03993.pdf''',
				    },
				    '''training_data''': {
				        '''Dataset''': '''English Wikipedia dump dated 2018-12-01''',
				        '''Preprocessing''': (
				            '''Using SentencePiece vocabulary of size 52k tokens. See details on'''
				            ''' https://arxiv.org/pdf/1810.03993.pdf'''
				        ),
				    },
				    '''quantitative_analyses''': {'''BLEU''': 55.1, '''ROUGE-1''': 7_6},
				}
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				self.assertTrue(hasattr(_A							, '''model_details'''		)		)
				self.assertTrue(hasattr(_A							, '''intended_use'''		)		)
				self.assertTrue(hasattr(_A							, '''factors'''		)		)
				self.assertTrue(hasattr(_A							, '''metrics'''		)		)
				self.assertTrue(hasattr(_A							, '''evaluation_data'''		)		)
				self.assertTrue(hasattr(_A							, '''training_data'''		)		)
				self.assertTrue(hasattr(_A							, '''quantitative_analyses'''		)		)
				self.assertTrue(hasattr(_A							, '''ethical_considerations'''		)		)
				self.assertTrue(hasattr(_A							, '''caveats_and_recommendations'''		)		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				UpperCAmelCase       		=    json.loads(modelcard.to_json_string()		)
				for key, value in self.inputs_dict.items():
							self.assertEqual(obj[key]							, _A		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase       		=    os.path.join(_A							, '''modelcard.json'''		)
							model_card_first.to_json_file(_A		)
							UpperCAmelCase       		=    ModelCard.from_json_file(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							model_card_first.save_pretrained(_A		)
							UpperCAmelCase       		=    ModelCard.from_pretrained(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)



