





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_  (       snake_case_   ,					snake_case_   ,					snake_case_   ,					unittest.TestCase ):

    '''simple docstring'''
    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     snake_case_(	self )	->     Tuple:
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    UNetaDConditionModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	sample_size=32				,	in_channels=9				,	out_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")				,	cross_attention_dim=32				,	)
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    ControlNetModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	in_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	cross_attention_dim=32				,	conditioning_embedding_out_channels=(16, 32)				,	)
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    DDIMScheduler(
            beta_start=0.0_0085				,	beta_end=0.012				,	beta_schedule="""scaled_linear"""				,	clip_sample=A				,	set_alpha_to_one=A				,	)
        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             =    CLIPTextConfig(
            bos_token_id=0				,	eos_token_id=2				,	hidden_size=32				,	intermediate_size=37				,	layer_norm_eps=1e-05				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=1000				,	)
        _SCREAMING_SNAKE_CASE             =    CLIPTextModel(A )
        _SCREAMING_SNAKE_CASE             =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

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


    def     snake_case_(	self				,	A				,	A=0 )	->     List[Any]:
        if str(A ).startswith("""mps""" ):
            _SCREAMING_SNAKE_CASE             =    torch.manual_seed(A )
        else:
            _SCREAMING_SNAKE_CASE             =    torch.Generator(device=A ).manual_seed(A )

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

        _SCREAMING_SNAKE_CASE             =    Image.fromarray(np.uinta(A ) ).convert("""RGB""" ).resize((64, 64) )
        _SCREAMING_SNAKE_CASE             =    Image.fromarray(np.uinta(init_image + 4 ) ).convert("""RGB""" ).resize((64, 64) )

        _SCREAMING_SNAKE_CASE             =    {
            """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     snake_case_(	self )	->     Union[str, Any]:
        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     snake_case_(	self )	->     Optional[int]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )





    def     snake_case_(	self )	->     Optional[int]:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3 )




class       a_  (       snake_case_ ):

    '''simple docstring'''
    UpperCamelCase									=				StableDiffusionControlNetInpaintPipeline
    UpperCamelCase									=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
    UpperCamelCase									=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
    UpperCamelCase									=				frozenset([] )


    def     snake_case_(	self )	->     Tuple:
        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				,	)
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    ControlNetModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	in_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	cross_attention_dim=32				,	conditioning_embedding_out_channels=(16, 32)				,	)
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    DDIMScheduler(
            beta_start=0.0_0085				,	beta_end=0.012				,	beta_schedule="""scaled_linear"""				,	clip_sample=A				,	set_alpha_to_one=A				,	)
        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             =    CLIPTextConfig(
            bos_token_id=0				,	eos_token_id=2				,	hidden_size=32				,	intermediate_size=37				,	layer_norm_eps=1e-05				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=1000				,	)
        _SCREAMING_SNAKE_CASE             =    CLIPTextModel(A )
        _SCREAMING_SNAKE_CASE             =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

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




class       a_  (       snake_case_   ,					snake_case_   ,					unittest.TestCase ):

    '''simple docstring'''
    UpperCamelCase									=				StableDiffusionControlNetInpaintPipeline
    UpperCamelCase									=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
    UpperCamelCase									=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS


    def     snake_case_(	self )	->     str:
        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    UNetaDConditionModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	sample_size=32				,	in_channels=9				,	out_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")				,	cross_attention_dim=32				,	)
        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 )

        _SCREAMING_SNAKE_CASE             =    ControlNetModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	in_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	cross_attention_dim=32				,	conditioning_embedding_out_channels=(16, 32)				,	)
        controlneta.controlnet_down_blocks.apply(A )

        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    ControlNetModel(
            block_out_channels=(32, 64)				,	layers_per_block=2				,	in_channels=4				,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,	cross_attention_dim=32				,	conditioning_embedding_out_channels=(16, 32)				,	)
        controlneta.controlnet_down_blocks.apply(A )

        torch.manual_seed(0 )
        _SCREAMING_SNAKE_CASE             =    DDIMScheduler(
            beta_start=0.0_0085				,	beta_end=0.012				,	beta_schedule="""scaled_linear"""				,	clip_sample=A				,	set_alpha_to_one=A				,	)
        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             =    CLIPTextConfig(
            bos_token_id=0				,	eos_token_id=2				,	hidden_size=32				,	intermediate_size=37				,	layer_norm_eps=1e-05				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=1000				,	)
        _SCREAMING_SNAKE_CASE             =    CLIPTextModel(A )
        _SCREAMING_SNAKE_CASE             =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

        _SCREAMING_SNAKE_CASE             =    MultiControlNetModel([controlneta, controlneta] )

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


    def     snake_case_(	self				,	A				,	A=0 )	->     Dict:
        if str(A ).startswith("""mps""" ):
            _SCREAMING_SNAKE_CASE             =    torch.manual_seed(A )
        else:
            _SCREAMING_SNAKE_CASE             =    torch.Generator(device=A ).manual_seed(A )

        _SCREAMING_SNAKE_CASE             =    2

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

        _SCREAMING_SNAKE_CASE             =    Image.fromarray(np.uinta(A ) ).convert("""RGB""" ).resize((64, 64) )
        _SCREAMING_SNAKE_CASE             =    Image.fromarray(np.uinta(init_image + 4 ) ).convert("""RGB""" ).resize((64, 64) )

        _SCREAMING_SNAKE_CASE             =    {
            """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     snake_case_(	self )	->     Union[str, Any]:
        _SCREAMING_SNAKE_CASE             =    self.get_dummy_components()
        _SCREAMING_SNAKE_CASE             =    self.pipeline_class(**A )
        pipe.to(A )

        _SCREAMING_SNAKE_CASE             =    10.0
        _SCREAMING_SNAKE_CASE             =    4

        _SCREAMING_SNAKE_CASE             =    self.get_dummy_inputs(A )
        _SCREAMING_SNAKE_CASE             =    steps
        _SCREAMING_SNAKE_CASE             =    scale
        _SCREAMING_SNAKE_CASE             =    pipe(**A )[0]

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

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

        _SCREAMING_SNAKE_CASE             =    self.get_dummy_inputs(A )
        _SCREAMING_SNAKE_CASE             =    steps
        _SCREAMING_SNAKE_CASE             =    scale
        _SCREAMING_SNAKE_CASE             =    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     snake_case_(	self )	->     Any:
        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     snake_case_(	self )	->     int:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )


    def     snake_case_(	self )	->     str:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3 )





    def     snake_case_(	self )	->     Tuple:
        _SCREAMING_SNAKE_CASE             =    self.get_dummy_components()
        _SCREAMING_SNAKE_CASE             =    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 ):

    '''simple docstring'''


    def     snake_case_(	self )	->     Optional[Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()


    def     snake_case_(	self )	->     Dict:
        _SCREAMING_SNAKE_CASE             =    ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny""" )

        _SCREAMING_SNAKE_CASE             =    StableDiffusionControlNetInpaintPipeline.from_pretrained(
            """runwayml/stable-diffusion-inpainting"""				,	safety_checker=A				,	controlnet=A )
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=A )

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

        _SCREAMING_SNAKE_CASE             =    load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
            """/stable_diffusion_inpaint/input_bench_mask.png""" ).resize((512, 512) )

        _SCREAMING_SNAKE_CASE             =    """pitch black hole"""

        _SCREAMING_SNAKE_CASE             =    load_image(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png""" ).resize((512, 512) )

        _SCREAMING_SNAKE_CASE             =    pipe(
            A				,	image=A				,	mask_image=A				,	control_image=A				,	generator=A				,	output_type="""np"""				,	num_inference_steps=3				,	)

        _SCREAMING_SNAKE_CASE             =    output.images[0]

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

        _SCREAMING_SNAKE_CASE             =    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     snake_case_(	self )	->     int:
        _SCREAMING_SNAKE_CASE             =    ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint""" )

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

        _SCREAMING_SNAKE_CASE             =    torch.Generator(device="""cpu""" ).manual_seed(33 )

        _SCREAMING_SNAKE_CASE             =    load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png""" )
        _SCREAMING_SNAKE_CASE             =    init_image.resize((512, 512) )

        _SCREAMING_SNAKE_CASE             =    load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png""" )
        _SCREAMING_SNAKE_CASE             =    mask_image.resize((512, 512) )

        _SCREAMING_SNAKE_CASE             =    """a handsome man with ray-ban sunglasses"""

        def make_inpaint_condition(A				,	A ):
            _SCREAMING_SNAKE_CASE             =    np.array(image.convert("""RGB""" ) ).astype(np.floataa ) / 255.0
            _SCREAMING_SNAKE_CASE             =    np.array(image_mask.convert("""L""" ) ).astype(np.floataa ) / 255.0

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

        _SCREAMING_SNAKE_CASE             =    make_inpaint_condition(A				,	A )

        _SCREAMING_SNAKE_CASE             =    pipe(
            A				,	image=A				,	mask_image=A				,	control_image=A				,	guidance_scale=9.0				,	eta=1.0				,	generator=A				,	num_inference_steps=20				,	output_type="""np"""				,	)
        _SCREAMING_SNAKE_CASE             =    output.images[0]

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

        _SCREAMING_SNAKE_CASE             =    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










'''simple docstring'''

import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard


class       a_  (       unittest.TestCase ):

    '''simple docstring'''


    def     snake_case_(	self )	->     int:
        _SCREAMING_SNAKE_CASE             =    {
            """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""": 76},
        }


    def     snake_case_(	self )	->     Tuple:
        _SCREAMING_SNAKE_CASE             =    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     snake_case_(	self )	->     List[str]:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
        _SCREAMING_SNAKE_CASE             =    json.loads(modelcard.to_json_string() )
        for key, value in self.inputs_dict.items():
            self.assertEqual(obj[key]				,	A )


    def     snake_case_(	self )	->     Any:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
            _SCREAMING_SNAKE_CASE             =    os.path.join(A				,	"""modelcard.json""" )
            model_card_first.to_json_file(A )
            _SCREAMING_SNAKE_CASE             =    ModelCard.from_json_file(A )

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





    def     snake_case_(	self )	->     List[Any]:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
            model_card_first.save_pretrained(A )
            _SCREAMING_SNAKE_CASE             =    ModelCard.from_pretrained(A )

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



