
"""simple docstring"""




# 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 	_lowercase    (							lowerCAmelCase_						, lowerCAmelCase_						, lowerCAmelCase_						, unittest.TestCase					):


     '''simple docstring'''





     _A		    =				StableDiffusionControlNetInpaintPipeline
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     _A		    =				frozenset({'control_image'}					)  # skip `image` and `mask` for now, only test for control_image
     _A		    =				TEXT_TO_IMAGE_IMAGE_PARAMS



     def 			lowerCAmelCase__							(   self	)->       Union[str, Any]:
          torch.manual_seed(0	)
          UpperCAmelCase__				:			Tuple							=    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	)
          UpperCAmelCase__				:			Dict							=    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	)
          UpperCAmelCase__				:			Optional[Any]							=    DDIMScheduler(
              beta_start=0.0_0085			,      beta_end=0.012			,      beta_schedule="scaled_linear"			,      clip_sample=__UpperCamelCase			,      set_alpha_to_one=__UpperCamelCase			,      )
          torch.manual_seed(0	)
          UpperCAmelCase__				:			Any							=    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	)
          UpperCAmelCase__				:			Optional[Any]							=    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=10_00			,      )
          UpperCAmelCase__				:			Optional[int]							=    CLIPTextModel(__UpperCamelCase	)
          UpperCAmelCase__				:			List[Any]							=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

          UpperCAmelCase__				:			List[str]							=    {
              "unet": unet,
              "controlnet": controlnet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          return components



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase=0	)->       Union[str, Any]:
          if str(__UpperCamelCase	).startswith("mps"	):
               UpperCAmelCase__				:			Optional[int]							=    torch.manual_seed(__UpperCamelCase	)
          else:
               UpperCAmelCase__				:			Optional[Any]							=    torch.Generator(device=__UpperCamelCase	).manual_seed(__UpperCamelCase	)

          UpperCAmelCase__				:			Optional[Any]							=    2
          UpperCAmelCase__				:			int							=    randn_tensor(
              (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,      generator=__UpperCamelCase			,      device=torch.device(__UpperCamelCase	)			,      )
          UpperCAmelCase__				:			Optional[Any]							=    floats_tensor((1, 3, 32, 32)			,      rng=random.Random(__UpperCamelCase	)	).to(__UpperCamelCase	)
          UpperCAmelCase__				:			Union[str, Any]							=    init_image.cpu().permute(0			,      2			,      3			,      1	)[0]

          UpperCAmelCase__				:			Dict							=    Image.fromarray(np.uinta(__UpperCamelCase	)	).convert("RGB"	).resize((64, 64)	)
          UpperCAmelCase__				:			Optional[Any]							=    Image.fromarray(np.uinta(init_image + 4	)	).convert("RGB"	).resize((64, 64)	)

          UpperCAmelCase__				:			Dict							=    {
              "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 			lowerCAmelCase__							(   self	)->       Dict:
          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 			lowerCAmelCase__							(   self	)->       Dict:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3	)



     def 			lowerCAmelCase__							(   self	)->       Dict:
          self._test_inference_batch_single_identical(expected_max_diff=2E-3	)







class 	_lowercase    (							lowerCAmelCase_					):


     '''simple docstring'''





     _A		    =				StableDiffusionControlNetInpaintPipeline
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     _A		    =				frozenset([]					)



     def 			lowerCAmelCase__							(   self	)->       Any:
          torch.manual_seed(0	)
          UpperCAmelCase__				:			str							=    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	)
          UpperCAmelCase__				:			List[str]							=    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	)
          UpperCAmelCase__				:			Optional[Any]							=    DDIMScheduler(
              beta_start=0.0_0085			,      beta_end=0.012			,      beta_schedule="scaled_linear"			,      clip_sample=__UpperCamelCase			,      set_alpha_to_one=__UpperCamelCase			,      )
          torch.manual_seed(0	)
          UpperCAmelCase__				:			int							=    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	)
          UpperCAmelCase__				:			List[Any]							=    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=10_00			,      )
          UpperCAmelCase__				:			List[str]							=    CLIPTextModel(__UpperCamelCase	)
          UpperCAmelCase__				:			str							=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

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







class 	_lowercase    (							lowerCAmelCase_						, lowerCAmelCase_						, unittest.TestCase					):


     '''simple docstring'''





     _A		    =				StableDiffusionControlNetInpaintPipeline
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     _A		    =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS



     def 			lowerCAmelCase__							(   self	)->       int:
          torch.manual_seed(0	)
          UpperCAmelCase__				:			int							=    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(__UpperCamelCase	):
               if isinstance(__UpperCamelCase			,      torch.nn.Convad	):
                    torch.nn.init.normal(m.weight	)
                    m.bias.data.fill_(1.0	)

          UpperCAmelCase__				:			Any							=    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(__UpperCamelCase	)

          torch.manual_seed(0	)
          UpperCAmelCase__				:			List[str]							=    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(__UpperCamelCase	)

          torch.manual_seed(0	)
          UpperCAmelCase__				:			List[Any]							=    DDIMScheduler(
              beta_start=0.0_0085			,      beta_end=0.012			,      beta_schedule="scaled_linear"			,      clip_sample=__UpperCamelCase			,      set_alpha_to_one=__UpperCamelCase			,      )
          torch.manual_seed(0	)
          UpperCAmelCase__				:			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			,      )
          torch.manual_seed(0	)
          UpperCAmelCase__				:			Optional[int]							=    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=10_00			,      )
          UpperCAmelCase__				:			Tuple							=    CLIPTextModel(__UpperCamelCase	)
          UpperCAmelCase__				:			Union[str, Any]							=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

          UpperCAmelCase__				:			Dict							=    MultiControlNetModel([controlneta, controlneta]	)

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



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase=0	)->       int:
          if str(__UpperCamelCase	).startswith("mps"	):
               UpperCAmelCase__				:			Tuple							=    torch.manual_seed(__UpperCamelCase	)
          else:
               UpperCAmelCase__				:			str							=    torch.Generator(device=__UpperCamelCase	).manual_seed(__UpperCamelCase	)

          UpperCAmelCase__				:			Dict							=    2

          UpperCAmelCase__				:			List[str]							=    [
              randn_tensor(
                  (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,      generator=__UpperCamelCase			,      device=torch.device(__UpperCamelCase	)			,      ),
              randn_tensor(
                  (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,      generator=__UpperCamelCase			,      device=torch.device(__UpperCamelCase	)			,      ),
          ]
          UpperCAmelCase__				:			int							=    floats_tensor((1, 3, 32, 32)			,      rng=random.Random(__UpperCamelCase	)	).to(__UpperCamelCase	)
          UpperCAmelCase__				:			int							=    init_image.cpu().permute(0			,      2			,      3			,      1	)[0]

          UpperCAmelCase__				:			str							=    Image.fromarray(np.uinta(__UpperCamelCase	)	).convert("RGB"	).resize((64, 64)	)
          UpperCAmelCase__				:			Any							=    Image.fromarray(np.uinta(init_image + 4	)	).convert("RGB"	).resize((64, 64)	)

          UpperCAmelCase__				:			Optional[int]							=    {
              "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 			lowerCAmelCase__							(   self	)->       List[str]:
          UpperCAmelCase__				:			str							=    self.get_dummy_components()
          UpperCAmelCase__				:			Optional[Any]							=    self.pipeline_class(**__UpperCamelCase	)
          pipe.to(__UpperCamelCase	)

          UpperCAmelCase__				:			str							=    10.0
          UpperCAmelCase__				:			Optional[int]							=    4

          UpperCAmelCase__				:			Optional[Any]							=    self.get_dummy_inputs(__UpperCamelCase	)
          UpperCAmelCase__				:			Tuple							=    steps
          UpperCAmelCase__				:			Tuple							=    scale
          UpperCAmelCase__				:			Union[str, Any]							=    pipe(**__UpperCamelCase	)[0]

          UpperCAmelCase__				:			Optional[Any]							=    self.get_dummy_inputs(__UpperCamelCase	)
          UpperCAmelCase__				:			List[str]							=    steps
          UpperCAmelCase__				:			Optional[Any]							=    scale
          UpperCAmelCase__				:			Tuple							=    pipe(**__UpperCamelCase			,      control_guidance_start=0.1			,      control_guidance_end=0.2	)[0]

          UpperCAmelCase__				:			List[Any]							=    self.get_dummy_inputs(__UpperCamelCase	)
          UpperCAmelCase__				:			Union[str, Any]							=    steps
          UpperCAmelCase__				:			str							=    scale
          UpperCAmelCase__				:			Union[str, Any]							=    pipe(**__UpperCamelCase			,      control_guidance_start=[0.1, 0.3]			,      control_guidance_end=[0.2, 0.7]	)[0]

          UpperCAmelCase__				:			List[str]							=    self.get_dummy_inputs(__UpperCamelCase	)
          UpperCAmelCase__				:			List[Any]							=    steps
          UpperCAmelCase__				:			Union[str, Any]							=    scale
          UpperCAmelCase__				:			str							=    pipe(**__UpperCamelCase			,      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 			lowerCAmelCase__							(   self	)->       List[str]:
          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 			lowerCAmelCase__							(   self	)->       str:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3	)



     def 			lowerCAmelCase__							(   self	)->       Dict:
          self._test_inference_batch_single_identical(expected_max_diff=2E-3	)



     def 			lowerCAmelCase__							(   self	)->       Dict:
          UpperCAmelCase__				:			Tuple							=    self.get_dummy_components()
          UpperCAmelCase__				:			Tuple							=    self.pipeline_class(**__UpperCamelCase	)
          pipe.to(__UpperCamelCase	)
          pipe.set_progress_bar_config(disable=__UpperCamelCase	)
          with tempfile.TemporaryDirectory() as tmpdir:
               try:
                    # save_pretrained is not implemented for Multi-ControlNet
                    pipe.save_pretrained(__UpperCamelCase	)
               except NotImplementedError:
                    pass







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


     '''simple docstring'''





     def 			lowerCAmelCase__							(   self	)->       Union[str, Any]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



     def 			lowerCAmelCase__							(   self	)->       Any:
          UpperCAmelCase__				:			Optional[int]							=    ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny"	)

          UpperCAmelCase__				:			List[Any]							=    StableDiffusionControlNetInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-inpainting"			,      safety_checker=__UpperCamelCase			,      controlnet=__UpperCamelCase	)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=__UpperCamelCase	)

          UpperCAmelCase__				:			Optional[int]							=    torch.Generator(device="cpu"	).manual_seed(0	)
          UpperCAmelCase__				:			Dict							=    load_image(
              "https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"	).resize((5_12, 5_12)	)

          UpperCAmelCase__				:			str							=    load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
              "/stable_diffusion_inpaint/input_bench_mask.png"	).resize((5_12, 5_12)	)

          UpperCAmelCase__				:			Union[str, Any]							=    "pitch black hole"

          UpperCAmelCase__				:			Union[str, Any]							=    load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"	).resize((5_12, 5_12)	)

          UpperCAmelCase__				:			Dict							=    pipe(
              __UpperCamelCase			,      image=__UpperCamelCase			,      mask_image=__UpperCamelCase			,      control_image=__UpperCamelCase			,      generator=__UpperCamelCase			,      output_type="np"			,      num_inference_steps=3			,      )

          UpperCAmelCase__				:			Optional[int]							=    output.images[0]

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

          UpperCAmelCase__				:			Tuple							=    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 			lowerCAmelCase__							(   self	)->       str:
          UpperCAmelCase__				:			Any							=    ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_inpaint"	)

          UpperCAmelCase__				:			Dict							=    StableDiffusionControlNetInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-v1-5"			,      safety_checker=__UpperCamelCase			,      controlnet=__UpperCamelCase	)
          UpperCAmelCase__				:			Any							=    DDIMScheduler.from_config(pipe.scheduler.config	)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=__UpperCamelCase	)

          UpperCAmelCase__				:			List[str]							=    torch.Generator(device="cpu"	).manual_seed(33	)

          UpperCAmelCase__				:			int							=    load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"	)
          UpperCAmelCase__				:			List[str]							=    init_image.resize((5_12, 5_12)	)

          UpperCAmelCase__				:			Any							=    load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"	)
          UpperCAmelCase__				:			Dict							=    mask_image.resize((5_12, 5_12)	)

          UpperCAmelCase__				:			Any							=    "a handsome man with ray-ban sunglasses"

          def make_inpaint_condition(__UpperCamelCase			,      __UpperCamelCase	):
               UpperCAmelCase__				:			Any							=    np.array(image.convert("RGB"	)	).astype(np.floataa	) / 255.0
               UpperCAmelCase__				:			Tuple							=    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"
               UpperCAmelCase__				:			str							=    -1.0  # set as masked pixel
               UpperCAmelCase__				:			Dict							=    np.expand_dims(__UpperCamelCase			,      0	).transpose(0			,      3			,      1			,      2	)
               UpperCAmelCase__				:			int							=    torch.from_numpy(__UpperCamelCase	)
               return image

          UpperCAmelCase__				:			Optional[int]							=    make_inpaint_condition(__UpperCamelCase			,      __UpperCamelCase	)

          UpperCAmelCase__				:			int							=    pipe(
              __UpperCamelCase			,      image=__UpperCamelCase			,      mask_image=__UpperCamelCase			,      control_image=__UpperCamelCase			,      guidance_scale=9.0			,      eta=1.0			,      generator=__UpperCamelCase			,      num_inference_steps=20			,      output_type="np"			,      )
          UpperCAmelCase__				:			Any							=    output.images[0]

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

          UpperCAmelCase__				:			Optional[int]							=    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 enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


A__   :						Optional[Any] 							=     set()
A__   :						List[str] 							=     get_logger(__name__)



def 				a__			(					lowerCAmelCase						:							Optional[str] = None		):






     '''simple docstring'''

     def decorator(lowerCAmelCase						:							Callable		):
          global _emitted_deprecation_warnings

          if inspect.isclass(lowerCAmelCase		):
               UpperCAmelCase__				:			Any							=    deprecated_class_or_function.__init__
               UpperCAmelCase__				:			Optional[int]							=    deprecated_class_or_function.__name__
          else:
               UpperCAmelCase__				:			str							=    deprecated_class_or_function
               UpperCAmelCase__				:			List[Any]							=    deprecated_function.__name__
               # Support deprecating __init__ class method: class name instead
               UpperCAmelCase__				:			List[str]							=    name if name != "__init__" else deprecated_function.__qualname__.split("."		)[-2]

          UpperCAmelCase__				:			Optional[Any]							=    (
              F"{name} is deprecated and will be removed in the next major version of datasets." + F" {help_message}"
              if help_message
              else ""
          )

          @wraps(lowerCAmelCase		)
          def wrapper(*lowerCAmelCase						:							int							,     **lowerCAmelCase						:							str		):
               UpperCAmelCase__				:			List[str]							=    hash(lowerCAmelCase		)
               if func_hash not in _emitted_deprecation_warnings:
                    warnings.warn(lowerCAmelCase							,     category=lowerCAmelCase							,     stacklevel=2		)
                    _emitted_deprecation_warnings.add(lowerCAmelCase		)
               return deprecated_function(*lowerCAmelCase							,     **lowerCAmelCase		)

          UpperCAmelCase__				:			List[str]							=    "deprecated"

          if inspect.isclass(lowerCAmelCase		):
               UpperCAmelCase__				:			List[str]							=    wrapper
               return deprecated_class_or_function
          else:
               return wrapper

     return decorator







class 	_lowercase    (							enum.EnumMeta					):


     '''simple docstring'''





     def __getattribute__(   cls			,      __UpperCamelCase	)->       Optional[Any]:
          UpperCAmelCase__				:			Optional[int]							=    super().__getattribute__(__UpperCamelCase	)
          if isinstance(__UpperCamelCase			,      enum.Enum	) and obj._on_access:
               obj._on_access()
          return obj



     def __getitem__(   cls			,      __UpperCamelCase	)->       Optional[int]:
          UpperCAmelCase__				:			Union[str, Any]							=    super().__getitem__(__UpperCamelCase	)
          if member._on_access:
               member._on_access()
          return member



     def __call__(   cls			,      __UpperCamelCase			,      __UpperCamelCase=None			,      *, __UpperCamelCase=None			,      __UpperCamelCase=None			,      __UpperCamelCase=None			,      __UpperCamelCase=1	)->       Dict:
          UpperCAmelCase__				:			Optional[int]							=    super().__call__(__UpperCamelCase			,      __UpperCamelCase			,      module=__UpperCamelCase			,      qualname=__UpperCamelCase			,      type=__UpperCamelCase			,      start=__UpperCamelCase	)
          if isinstance(__UpperCamelCase			,      enum.Enum	) and obj._on_access:
               obj._on_access()
          return obj







class 	_lowercase    (							enum.Enum						, metaclass=lowerCAmelCase_					):


     '''simple docstring'''





     def __new__(   cls			,      __UpperCamelCase	)->       Union[str, Any]:
          UpperCAmelCase__				:			int							=    object.__new__(cls	)
          UpperCAmelCase__				:			int							=    value
          UpperCAmelCase__				:			Optional[int]							=    member.deprecate
          return member



     @property
     def 			lowerCAmelCase__							(   self	)->       Union[str, Any]:
          return ""



     def 			lowerCAmelCase__							(   self	)->       int:
          UpperCAmelCase__				:			Tuple							=    F" {self.help_message}" if self.help_message else ""
          warnings.warn(
              F"'{self.__objclass__.__name__}' is deprecated and will be removed in the next major version of datasets."
              + help_message			,      __UpperCamelCase			,      stacklevel=3			,      )



