

"""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     __a   (      snake_case__,    snake_case__,    snake_case__,    unittest.TestCase    ):

			"""simple docstring"""

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






			def    _lowerCAmelCase			(							self     :					Optional[Any]						):
								torch.manual_seed(0						)
								UpperCamelCase__		:    Optional[Any]         =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__		:    Optional[int]         =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__		:    str         =DDIMScheduler(
								    beta_start=0.0_0_0_8_5						,  beta_end=0.0_1_2						,  beta_schedule='''scaled_linear'''						,  clip_sample=lowercase_						,  set_alpha_to_one=lowercase_						,  )
								torch.manual_seed(0						)
								UpperCamelCase__		:    List[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__		:    str         =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						,  )
								UpperCamelCase__		:    Tuple         =CLIPTextModel(lowercase_						)
								UpperCamelCase__		:    Optional[Any]         =CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						)

								UpperCamelCase__		:    Optional[int]         ={
								    '''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     :					str						,  lowercase_     :					Dict						,  lowercase_     :					Union[str, Any]=0						):
								if str(lowercase_						).startswith('''mps'''						):
													UpperCamelCase__		:    Optional[Any]         =torch.manual_seed(lowercase_						)
								else:
													UpperCamelCase__		:    List[Any]         =torch.Generator(device=lowercase_						).manual_seed(lowercase_						)

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

								UpperCamelCase__		:    List[Any]         =Image.fromarray(np.uinta(lowercase_						)						).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     :					int						):
								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     :					List[Any]						):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3						)






			def    _lowerCAmelCase			(							self     :					Union[str, Any]						):
								self._test_inference_batch_single_identical(expected_max_diff=2e-3						)



class     __a   (      snake_case__    ):

			"""simple docstring"""

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






			def    _lowerCAmelCase			(							self     :					Optional[Any]						):
								torch.manual_seed(0						)
								UpperCamelCase__		:    List[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						,  )
								torch.manual_seed(0						)
								UpperCamelCase__		:    Tuple         =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__		:    List[Any]         =DDIMScheduler(
								    beta_start=0.0_0_0_8_5						,  beta_end=0.0_1_2						,  beta_schedule='''scaled_linear'''						,  clip_sample=lowercase_						,  set_alpha_to_one=lowercase_						,  )
								torch.manual_seed(0						)
								UpperCamelCase__		:    List[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__		:    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=1000						,  )
								UpperCamelCase__		:    str         =CLIPTextModel(lowercase_						)
								UpperCamelCase__		:    List[Any]         =CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						)

								UpperCamelCase__		:    Any         ={
								    '''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"""

			SCREAMING_SNAKE_CASE_						     =						StableDiffusionControlNetInpaintPipeline
			SCREAMING_SNAKE_CASE_						     =						TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			SCREAMING_SNAKE_CASE_						     =						TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS






			def    _lowerCAmelCase			(							self     :					Union[str, Any]						):
								torch.manual_seed(0						)
								UpperCamelCase__		:    Optional[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(lowercase_     :					int						):
													if isinstance(lowercase_						,  torch.nn.Convad						):
																		torch.nn.init.normal(m.weight						)
																		m.bias.data.fill_(1.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(lowercase_						)

								torch.manual_seed(0						)
								UpperCamelCase__		:    Tuple         =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(lowercase_						)

								torch.manual_seed(0						)
								UpperCamelCase__		:    Any         =DDIMScheduler(
								    beta_start=0.0_0_0_8_5						,  beta_end=0.0_1_2						,  beta_schedule='''scaled_linear'''						,  clip_sample=lowercase_						,  set_alpha_to_one=lowercase_						,  )
								torch.manual_seed(0						)
								UpperCamelCase__		:    Tuple         =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__		:    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=1000						,  )
								UpperCamelCase__		:    Union[str, Any]         =CLIPTextModel(lowercase_						)
								UpperCamelCase__		:    List[Any]         =CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						)

								UpperCamelCase__		:    List[Any]         =MultiControlNetModel([controlneta, controlneta]						)

								UpperCamelCase__		:    Union[str, Any]         ={
								    '''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     :					Optional[int]						,  lowercase_     :					List[Any]						,  lowercase_     :					Any=0						):
								if str(lowercase_						).startswith('''mps'''						):
													UpperCamelCase__		:    Optional[Any]         =torch.manual_seed(lowercase_						)
								else:
													UpperCamelCase__		:    List[str]         =torch.Generator(device=lowercase_						).manual_seed(lowercase_						)

								UpperCamelCase__		:    int         =2

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

								UpperCamelCase__		:    Any         =Image.fromarray(np.uinta(lowercase_						)						).convert('''RGB'''						).resize((64, 64)						)
								UpperCamelCase__		:    int         =Image.fromarray(np.uinta(init_image + 4						)						).convert('''RGB'''						).resize((64, 64)						)

								UpperCamelCase__		:    Union[str, Any]         ={
								    '''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     :					Union[str, Any]						):
								UpperCamelCase__		:    List[Any]         =self.get_dummy_components()
								UpperCamelCase__		:    Any         =self.pipeline_class(**lowercase_						)
								pipe.to(lowercase_						)

								UpperCamelCase__		:    Union[str, Any]         =1_0.0
								UpperCamelCase__		:    Optional[int]         =4

								UpperCamelCase__		:    Optional[Any]         =self.get_dummy_inputs(lowercase_						)
								UpperCamelCase__		:    Union[str, Any]         =steps
								UpperCamelCase__		:    List[str]         =scale
								UpperCamelCase__		:    Union[str, Any]         =pipe(**lowercase_						)[0]

								UpperCamelCase__		:    Dict         =self.get_dummy_inputs(lowercase_						)
								UpperCamelCase__		:    int         =steps
								UpperCamelCase__		:    List[Any]         =scale
								UpperCamelCase__		:    str         =pipe(**lowercase_						,  control_guidance_start=0.1						,  control_guidance_end=0.2						)[0]

								UpperCamelCase__		:    Dict         =self.get_dummy_inputs(lowercase_						)
								UpperCamelCase__		:    Dict         =steps
								UpperCamelCase__		:    Optional[int]         =scale
								UpperCamelCase__		:    Any         =pipe(**lowercase_						,  control_guidance_start=[0.1, 0.3]						,  control_guidance_end=[0.2, 0.7]						)[0]

								UpperCamelCase__		:    str         =self.get_dummy_inputs(lowercase_						)
								UpperCamelCase__		:    Union[str, Any]         =steps
								UpperCamelCase__		:    Optional[Any]         =scale
								UpperCamelCase__		:    str         =pipe(**lowercase_						,  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     :					Dict						):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3						)






			def    _lowerCAmelCase			(							self     :					List[str]						):
								self._test_inference_batch_single_identical(expected_max_diff=2e-3						)






			def    _lowerCAmelCase			(							self     :					Optional[Any]						):
								UpperCamelCase__		:    Optional[int]         =self.get_dummy_components()
								UpperCamelCase__		:    List[Any]         =self.pipeline_class(**lowercase_						)
								pipe.to(lowercase_						)
								pipe.set_progress_bar_config(disable=lowercase_						)
								with tempfile.TemporaryDirectory() as tmpdir:
													try:
																		# save_pretrained is not implemented for Multi-ControlNet
																		pipe.save_pretrained(lowercase_						)
													except NotImplementedError:
																		pass



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

			"""simple docstring"""

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






			def    _lowerCAmelCase			(							self     :					int						):
								UpperCamelCase__		:    Optional[Any]         =ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''						)

								UpperCamelCase__		:    Tuple         =StableDiffusionControlNetInpaintPipeline.from_pretrained(
								    '''runwayml/stable-diffusion-inpainting'''						,  safety_checker=lowercase_						,  controlnet=lowercase_						)
								pipe.enable_model_cpu_offload()
								pipe.set_progress_bar_config(disable=lowercase_						)

								UpperCamelCase__		:    Optional[Any]         =torch.Generator(device='''cpu'''						).manual_seed(0						)
								UpperCamelCase__		:    Optional[Any]         =load_image(
								    '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''						).resize((512, 512)						)

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

								UpperCamelCase__		:    List[str]         ='''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((512, 512)						)

								UpperCamelCase__		:    Tuple         =pipe(
								    lowercase_						,  image=lowercase_						,  mask_image=lowercase_						,  control_image=lowercase_						,  generator=lowercase_						,  output_type='''np'''						,  num_inference_steps=3						,  )

								UpperCamelCase__		:    Tuple         =output.images[0]

								assert image.shape == (512, 512, 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     :					int						):
								UpperCamelCase__		:    Tuple         =ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''						)

								UpperCamelCase__		:    str         =StableDiffusionControlNetInpaintPipeline.from_pretrained(
								    '''runwayml/stable-diffusion-v1-5'''						,  safety_checker=lowercase_						,  controlnet=lowercase_						)
								UpperCamelCase__		:    Union[str, Any]         =DDIMScheduler.from_config(pipe.scheduler.config						)
								pipe.enable_model_cpu_offload()
								pipe.set_progress_bar_config(disable=lowercase_						)

								UpperCamelCase__		:    Optional[Any]         =torch.Generator(device='''cpu'''						).manual_seed(33						)

								UpperCamelCase__		:    Union[str, Any]         =load_image(
								    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'''						)
								UpperCamelCase__		:    Union[str, Any]         =init_image.resize((512, 512)						)

								UpperCamelCase__		:    Dict         =load_image(
								    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'''						)
								UpperCamelCase__		:    Optional[Any]         =mask_image.resize((512, 512)						)

								UpperCamelCase__		:    Union[str, Any]         ='''a handsome man with ray-ban sunglasses'''

								def make_inpaint_condition(lowercase_     :					List[str]						,  lowercase_     :					Any						):
													UpperCamelCase__		:    List[str]         =np.array(image.convert('''RGB'''						)						).astype(np.floataa						) / 2_5_5.0
													UpperCamelCase__		:    Any         =np.array(image_mask.convert('''L'''						)						).astype(np.floataa						) / 2_5_5.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__		:    str         =np.expand_dims(lowercase_						,  0						).transpose(0						,  3						,  1						,  2						)
													UpperCamelCase__		:    int         =torch.from_numpy(lowercase_						)
													return image

								UpperCamelCase__		:    List[Any]         =make_inpaint_condition(lowercase_						,  lowercase_						)

								UpperCamelCase__		:    Tuple         =pipe(
								    lowercase_						,  image=lowercase_						,  mask_image=lowercase_						,  control_image=lowercase_						,  guidance_scale=9.0						,  eta=1.0						,  generator=lowercase_						,  num_inference_steps=20						,  output_type='''np'''						,  )
								UpperCamelCase__		:    Dict         =output.images[0]

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

								UpperCamelCase__		:    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"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


_SCREAMING_SNAKE_CASE       :  Union[str, Any]        = {
    """configuration_xlm_prophetnet""": ["""XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLMProphetNetConfig"""],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_SCREAMING_SNAKE_CASE       :  Any        = ["""XLMProphetNetTokenizer"""]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_SCREAMING_SNAKE_CASE       :  Optional[Any]        = [
				    """XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """XLMProphetNetDecoder""",
				    """XLMProphetNetEncoder""",
				    """XLMProphetNetForCausalLM""",
				    """XLMProphetNetForConditionalGeneration""",
				    """XLMProphetNetModel""",
				    """XLMProphetNetPreTrainedModel""",
				]


if TYPE_CHECKING:
				from .configuration_xlm_prophetnet import XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMProphetNetConfig

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_xlm_prophetnet import XLMProphetNetTokenizer

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_xlm_prophetnet import (
								    XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    XLMProphetNetDecoder,
								    XLMProphetNetEncoder,
								    XLMProphetNetForCausalLM,
								    XLMProphetNetForConditionalGeneration,
								    XLMProphetNetModel,
								    XLMProphetNetPreTrainedModel,
								)

else:
				import sys

				_SCREAMING_SNAKE_CASE       :  Dict        = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


