



'''simple docstring'''






import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu



class 							lowercase       (  unittest.TestCase				):


 """simple docstring"""


 def _snake_case (							self							)		->   str:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







 @property
 def _snake_case (							self							)		->   str:
        _UpperCAmelCase  :						str			     = 1
        _UpperCAmelCase  :						Dict			     = 3
        _UpperCAmelCase  :						Any			     = (32, 32)

        _UpperCAmelCase  :						Union[str, Any]			     = floats_tensor((batch_size, num_channels) + sizes  ,rng=random.Random(0							)							).to(a_							)
        return image







 @property
 def _snake_case (							self							)		->   Union[str, Any]:
        torch.manual_seed(0							)
        _UpperCAmelCase  :						Optional[Any]			     = 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  ,)
        return model







 @property
 def _snake_case (							self							)		->   List[Any]:
        torch.manual_seed(0							)
        _UpperCAmelCase  :						List[str]			     = 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  ,)
        return model







 @property
 def _snake_case (							self							)		->   str:
        torch.manual_seed(0							)
        _UpperCAmelCase  :						int			     = CLIPTextConfig(
            bos_token_id=0  ,eos_token_id=2  ,hidden_size=32  ,intermediate_size=37  ,layer_norm_eps=1E-0_5  ,num_attention_heads=4  ,num_hidden_layers=5  ,pad_token_id=1  ,vocab_size=1_000  ,)
        return CLIPTextModel(a_							)







 @property
 def _snake_case (							self							)		->   str:
        def extract(*a_  ,**a_							):



               class 							lowercase       :


                """simple docstring"""


                def __init__(							self							)		->   Tuple:
                       _UpperCAmelCase  :						str			     = torch.ones([0]							)







                def _snake_case (							self  ,a_							)		->   List[Any]:
                       self.pixel_values.to(a_							)
                       return self







               return Out()

        return extract







 def _snake_case (							self							)		->   int:
        _UpperCAmelCase  :						List[str]			     = """cpu"""  # ensure determinism for the device-dependent torch.Generator
        _UpperCAmelCase  :						int			     = self.dummy_cond_unet
        _UpperCAmelCase  :						str			     = DDIMScheduler(
            beta_start=0.0_0085  ,beta_end=0.012  ,beta_schedule="""scaled_linear"""  ,clip_sample=a_  ,set_alpha_to_one=a_  ,)

        _UpperCAmelCase  :						Optional[int]			     = self.dummy_vae
        _UpperCAmelCase  :						List[Any]			     = self.dummy_text_encoder
        _UpperCAmelCase  :						Optional[Any]			     = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

        # make sure here that pndm scheduler skips prk
        _UpperCAmelCase  :						Tuple			     = StableDiffusionPipeline(
            unet=a_  ,scheduler=a_  ,vae=a_  ,text_encoder=a_  ,tokenizer=a_  ,safety_checker=a_  ,feature_extractor=self.dummy_extractor  ,)
        _UpperCAmelCase  :						Optional[Any]			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						Union[str, Any]			     = """A painting of a squirrel eating a burger"""

        _UpperCAmelCase  :						List[str]			     = torch.Generator(device=a_							).manual_seed(0							)
        _UpperCAmelCase  :						Dict			     = sd_pipe([prompt]  ,generator=a_  ,guidance_scale=6.0  ,num_inference_steps=2  ,output_type="""np"""							)
        _UpperCAmelCase  :						int			     = output.images

        _UpperCAmelCase  :						List[str]			     = torch.Generator(device=a_							).manual_seed(0							)
        _UpperCAmelCase  :						Optional[Any]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=6.0  ,num_inference_steps=2  ,output_type="""np"""  ,return_dict=a_  ,)[0]

        _UpperCAmelCase  :						Optional[Any]			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						List[str]			     = image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        _UpperCAmelCase  :						Dict			     = np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]							)

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







 def _snake_case (							self							)		->   Union[str, Any]:
        _UpperCAmelCase  :						Dict			     = """cpu"""  # ensure determinism for the device-dependent torch.Generator
        _UpperCAmelCase  :						Any			     = self.dummy_cond_unet
        _UpperCAmelCase  :						List[str]			     = PNDMScheduler(skip_prk_steps=a_							)
        _UpperCAmelCase  :						str			     = self.dummy_vae
        _UpperCAmelCase  :						Optional[int]			     = self.dummy_text_encoder
        _UpperCAmelCase  :						Union[str, Any]			     = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

        # make sure here that pndm scheduler skips prk
        _UpperCAmelCase  :						Optional[int]			     = StableDiffusionPipeline(
            unet=a_  ,scheduler=a_  ,vae=a_  ,text_encoder=a_  ,tokenizer=a_  ,safety_checker=a_  ,feature_extractor=self.dummy_extractor  ,)
        _UpperCAmelCase  :						Dict			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						str			     = """A painting of a squirrel eating a burger"""
        _UpperCAmelCase  :						Dict			     = torch.Generator(device=a_							).manual_seed(0							)
        _UpperCAmelCase  :						str			     = sd_pipe([prompt]  ,generator=a_  ,guidance_scale=6.0  ,num_inference_steps=2  ,output_type="""np"""							)

        _UpperCAmelCase  :						Tuple			     = output.images

        _UpperCAmelCase  :						Optional[int]			     = torch.Generator(device=a_							).manual_seed(0							)
        _UpperCAmelCase  :						List[Any]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=6.0  ,num_inference_steps=2  ,output_type="""np"""  ,return_dict=a_  ,)[0]

        _UpperCAmelCase  :						List[Any]			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						List[Any]			     = image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        _UpperCAmelCase  :						List[Any]			     = np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]							)

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







 def _snake_case (							self							)		->   int:
        _UpperCAmelCase  :						Optional[Any]			     = StableDiffusionPipeline.from_pretrained(
            """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""  ,safety_checker=a_							)
        assert isinstance(a_  ,a_							)
        assert isinstance(pipe.scheduler  ,a_							)
        assert pipe.safety_checker is None

        _UpperCAmelCase  :						List[str]			     = pipe("""example prompt"""  ,num_inference_steps=2							).images[0]
        assert image is not None

        # check that there's no error when saving a pipeline with one of the models being None
        with tempfile.TemporaryDirectory() as tmpdirname:
               pipe.save_pretrained(a_							)
               _UpperCAmelCase  :						int			     = StableDiffusionPipeline.from_pretrained(a_							)

        # sanity check that the pipeline still works
        assert pipe.safety_checker is None
        _UpperCAmelCase  :						Dict			     = pipe("""example prompt"""  ,num_inference_steps=2							).images[0]
        assert image is not None







 @unittest.skipIf(torch_device != """cuda"""  ,"""This test requires a GPU"""							)
 def _snake_case (							self							)		->   List[Any]:
        _UpperCAmelCase  :						Dict			     = self.dummy_cond_unet
        _UpperCAmelCase  :						Optional[int]			     = PNDMScheduler(skip_prk_steps=a_							)
        _UpperCAmelCase  :						Tuple			     = self.dummy_vae
        _UpperCAmelCase  :						List[str]			     = self.dummy_text_encoder
        _UpperCAmelCase  :						Dict			     = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

        # put models in fp16
        _UpperCAmelCase  :						Union[str, Any]			     = unet.half()
        _UpperCAmelCase  :						List[str]			     = vae.half()
        _UpperCAmelCase  :						Optional[Any]			     = bert.half()

        # make sure here that pndm scheduler skips prk
        _UpperCAmelCase  :						str			     = StableDiffusionPipeline(
            unet=a_  ,scheduler=a_  ,vae=a_  ,text_encoder=a_  ,tokenizer=a_  ,safety_checker=a_  ,feature_extractor=self.dummy_extractor  ,)
        _UpperCAmelCase  :						Union[str, Any]			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						Optional[Any]			     = """A painting of a squirrel eating a burger"""
        _UpperCAmelCase  :						Optional[int]			     = sd_pipe([prompt]  ,num_inference_steps=2  ,output_type="""np"""							).images

        assert image.shape == (1, 64, 64, 3)







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


 """simple docstring"""


 def _snake_case (							self							)		->   List[str]:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







 def _snake_case (							self							)		->   List[Any]:
        _UpperCAmelCase  :						List[Any]			     = StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""  ,safety_checker=a_							)
        _UpperCAmelCase  :						Tuple			     = LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config							)
        _UpperCAmelCase  :						Dict			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						Any			     = (
            """portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"""
            """ coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"""
            """ anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"""
            """ children from bahnhof zoo, detailed """
        )
        _UpperCAmelCase  :						List[str]			     = 4_003_660_346
        _UpperCAmelCase  :						List[Any]			     = 7

        # without safety guidance (sld_guidance_scale = 0)
        _UpperCAmelCase  :						Any			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						List[str]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=0  ,)

        _UpperCAmelCase  :						List[str]			     = output.images
        _UpperCAmelCase  :						Optional[int]			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						int			     = [0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

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

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

        # without safety guidance (strong configuration)
        _UpperCAmelCase  :						str			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						Optional[int]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=2_000  ,sld_warmup_steps=7  ,sld_threshold=0.025  ,sld_momentum_scale=0.5  ,sld_mom_beta=0.7  ,)

        _UpperCAmelCase  :						Optional[int]			     = output.images
        _UpperCAmelCase  :						List[Any]			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						int			     = [0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

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

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







 def _snake_case (							self							)		->   Optional[int]:
        _UpperCAmelCase  :						Union[str, Any]			     = StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""  ,safety_checker=a_							)
        _UpperCAmelCase  :						Tuple			     = LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config							)
        _UpperCAmelCase  :						Tuple			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						List[str]			     = """padme amidala taking a bath artwork, safe for work, no nudity"""
        _UpperCAmelCase  :						str			     = 2_734_971_755
        _UpperCAmelCase  :						Dict			     = 7

        _UpperCAmelCase  :						str			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						Union[str, Any]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=0  ,)

        _UpperCAmelCase  :						List[str]			     = output.images
        _UpperCAmelCase  :						Dict			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						str			     = [0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

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

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

        _UpperCAmelCase  :						List[str]			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						List[str]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=2_000  ,sld_warmup_steps=7  ,sld_threshold=0.025  ,sld_momentum_scale=0.5  ,sld_mom_beta=0.7  ,)

        _UpperCAmelCase  :						Dict			     = output.images
        _UpperCAmelCase  :						str			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						Dict			     = [0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

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

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







 def _snake_case (							self							)		->   Optional[int]:
        _UpperCAmelCase  :						Any			     = StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""							)
        _UpperCAmelCase  :						List[str]			     = sd_pipe.to(a_							)
        sd_pipe.set_progress_bar_config(disable=a_							)

        _UpperCAmelCase  :						List[str]			     = (
            """the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."""
            """ leyendecker"""
        )
        _UpperCAmelCase  :						Tuple			     = 1_044_355_234
        _UpperCAmelCase  :						Dict			     = 12

        _UpperCAmelCase  :						str			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						Union[str, Any]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=0  ,)

        _UpperCAmelCase  :						Any			     = output.images
        _UpperCAmelCase  :						List[Any]			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						int			     = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]							)

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

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

        _UpperCAmelCase  :						str			     = torch.manual_seed(a_							)
        _UpperCAmelCase  :						List[str]			     = sd_pipe(
            [prompt]  ,generator=a_  ,guidance_scale=a_  ,num_inference_steps=50  ,output_type="""np"""  ,width=512  ,height=512  ,sld_guidance_scale=2_000  ,sld_warmup_steps=7  ,sld_threshold=0.025  ,sld_momentum_scale=0.5  ,sld_mom_beta=0.7  ,)

        _UpperCAmelCase  :						Any			     = output.images
        _UpperCAmelCase  :						Dict			     = image[0, -3:, -3:, -1]
        _UpperCAmelCase  :						Dict			     = np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]							)
        assert image.shape == (1, 512, 512, 3)

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





# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from packaging import version

from .. import __version__
from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD
from .doc import (
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    copy_func,
    replace_return_docstrings,
)
from .generic import (
    ContextManagers,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    TensorType,
    add_model_info_to_auto_map,
    cached_property,
    can_return_loss,
    expand_dims,
    find_labels,
    flatten_dict,
    infer_framework,
    is_jax_tensor,
    is_numpy_array,
    is_tensor,
    is_tf_symbolic_tensor,
    is_tf_tensor,
    is_torch_device,
    is_torch_dtype,
    is_torch_tensor,
    reshape,
    squeeze,
    strtobool,
    tensor_size,
    to_numpy,
    to_py_obj,
    transpose,
    working_or_temp_dir,
)
from .hub import (
    CLOUDFRONT_DISTRIB_PREFIX,
    DISABLE_TELEMETRY,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    EntryNotFoundError,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    cached_file,
    default_cache_path,
    define_sagemaker_information,
    download_url,
    extract_commit_hash,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    has_file,
    http_user_agent,
    is_offline_mode,
    is_remote_url,
    move_cache,
    send_example_telemetry,
    try_to_load_from_cache,
)
from .import_utils import (
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    TORCH_FX_REQUIRED_VERSION,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    _LazyModule,
    ccl_version,
    direct_transformers_import,
    get_torch_version,
    is_accelerate_available,
    is_apex_available,
    is_bitsandbytes_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_cython_available,
    is_datasets_available,
    is_decord_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_jieba_available,
    is_jumanpp_available,
    is_kenlm_available,
    is_keras_nlp_available,
    is_librosa_available,
    is_natten_available,
    is_ninja_available,
    is_onnx_available,
    is_openai_available,
    is_optimum_available,
    is_pandas_available,
    is_peft_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytest_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sacremoses_available,
    is_safetensors_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_sudachi_available,
    is_tensorflow_probability_available,
    is_tensorflow_text_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_bfaa_cpu_available,
    is_torch_bfaa_gpu_available,
    is_torch_compile_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_neuroncore_available,
    is_torch_tensorrt_fx_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_torchdistx_available,
    is_torchdynamo_available,
    is_torchvision_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    requires_backends,
    torch_only_method,
)


SCREAMING_SNAKE_CASE							:List[str]							 =				'pytorch_model.bin'
SCREAMING_SNAKE_CASE							:str							 =				'pytorch_model.bin.index.json'
SCREAMING_SNAKE_CASE							:Optional[int]							 =				'adapter_config.json'
SCREAMING_SNAKE_CASE							:Dict							 =				'adapter_model.bin'
SCREAMING_SNAKE_CASE							:Dict							 =				'adapter_model.safetensors'
SCREAMING_SNAKE_CASE							:str							 =				'tf_model.h5'
SCREAMING_SNAKE_CASE							:List[Any]							 =				'tf_model.h5.index.json'
SCREAMING_SNAKE_CASE							:str							 =				'model.ckpt'
SCREAMING_SNAKE_CASE							:List[Any]							 =				'flax_model.msgpack'
SCREAMING_SNAKE_CASE							:Optional[int]							 =				'flax_model.msgpack.index.json'
SCREAMING_SNAKE_CASE							:Tuple							 =				'model.safetensors'
SCREAMING_SNAKE_CASE							:List[Any]							 =				'model.safetensors.index.json'
SCREAMING_SNAKE_CASE							:str							 =				'config.json'
SCREAMING_SNAKE_CASE							:int							 =				'preprocessor_config.json'
SCREAMING_SNAKE_CASE							:Optional[Any]							 =				FEATURE_EXTRACTOR_NAME
SCREAMING_SNAKE_CASE							:Optional[int]							 =				'generation_config.json'
SCREAMING_SNAKE_CASE							:List[str]							 =				'modelcard.json'

SCREAMING_SNAKE_CASE							:Optional[int]							 =				'▁'
SCREAMING_SNAKE_CASE							:Optional[Any]							 =				SENTENCEPIECE_UNDERLINE  # Kept for backward compatibility

SCREAMING_SNAKE_CASE							:str							 =				[
    [[0, 1, 0, 1], [1, 0, 0, 1]]
] * 2  # Needs to have 0s and 1s only since XLM uses it for langs too.
SCREAMING_SNAKE_CASE							:Optional[Any]							 =				[[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]]
SCREAMING_SNAKE_CASE							:List[Any]							 =				[[1, 1, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 1, 1]]


def 						UpperCAmelCase			(	a_						)		->	Dict:







				"""simple docstring"""



				if version.parse(a_						) < version.parse(a_						):
								if "dev" in min_version:
												__A   			= (
												    "This example requires a source install from HuggingFace Transformers (see "
												    "`https://huggingface.co/docs/transformers/installation#install-from-source`),"
												)
								else:
												__A   			= F'''This example requires a minimum version of {min_version},'''
								error_message += F''' but the version found is {__version__}.\n'''
								raise ImportError(
								    error_message
								    + "Check out https://github.com/huggingface/transformers/tree/main/examples#important-note for the examples corresponding to other "
								    "versions of HuggingFace Transformers."						)
