


"""simple docstring"""






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     _UpperCAmelCase			(		__a    ,     __a    ,     __a    ,     unittest.TestCase):
			__a :       Union[str, Any]									=							StableDiffusionControlNetInpaintPipeline
			__a :       Union[str, Any]									=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a :       Any									=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			__a :       Optional[int]									=							frozenset({"""control_image"""})  # skip `image` and `mask` for now, only test for control_image
			__a :       Optional[Any]									=							TEXT_TO_IMAGE_IMAGE_PARAMS
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				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    :							Union[str, 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)      ,		)
				torch.manual_seed(0     )
				_UpperCAmelCase    :							int									=					DDIMScheduler(
				    beta_start=0.00085      ,		beta_end=0.012      ,		beta_schedule="""scaled_linear"""      ,		clip_sample=_A      ,		set_alpha_to_one=_A      ,		)
				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    :							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    :							str									=					CLIPTextModel(_A     )
				_UpperCAmelCase    :							int									=					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 							__snake_case (		self      ,		_A      ,		_A=0     )    ->    Optional[int]:






				'''simple docstring'''







				if str(_A     ).startswith("""mps"""     ):
					_UpperCAmelCase    :							str									=					torch.manual_seed(_A     )
				else:
					_UpperCAmelCase    :							Optional[Any]									=					torch.Generator(device=_A     ).manual_seed(_A     )

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

				_UpperCAmelCase    :							Any									=					Image.fromarray(np.uinta(_A     )     ).convert("""RGB"""     ).resize((64, 64)     )
				_UpperCAmelCase    :							str									=					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 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







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






				'''simple docstring'''







				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3     )
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				self._test_inference_batch_single_identical(expected_max_diff=2e-3     )






class     _UpperCAmelCase			(		__a):
			__a :       int									=							StableDiffusionControlNetInpaintPipeline
			__a :       Optional[Any]									=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a :       Tuple									=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			__a :       Optional[int]									=							frozenset([])
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				torch.manual_seed(0     )
				_UpperCAmelCase    :							List[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    :							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    :							Any									=					DDIMScheduler(
				    beta_start=0.00085      ,		beta_end=0.012      ,		beta_schedule="""scaled_linear"""      ,		clip_sample=_A      ,		set_alpha_to_one=_A      ,		)
				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    :							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    :							Any									=					CLIPTextModel(_A     )
				_UpperCAmelCase    :							Optional[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     _UpperCAmelCase			(		__a    ,     __a    ,     unittest.TestCase):
			__a :       Optional[Any]									=							StableDiffusionControlNetInpaintPipeline
			__a :       Union[str, Any]									=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a :       Any									=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				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(_A     ):
					if isinstance(_A      ,		torch.nn.Convad     ):
						torch.nn.init.normal(m.weight     )
						m.bias.data.fill_(1.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(_A     )

				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(_A     )

				torch.manual_seed(0     )
				_UpperCAmelCase    :							List[str]									=					DDIMScheduler(
				    beta_start=0.00085      ,		beta_end=0.012      ,		beta_schedule="""scaled_linear"""      ,		clip_sample=_A      ,		set_alpha_to_one=_A      ,		)
				torch.manual_seed(0     )
				_UpperCAmelCase    :							Dict									=					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    :							Tuple									=					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    :							int									=					CLIPTextModel(_A     )
				_UpperCAmelCase    :							str									=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

				_UpperCAmelCase    :							Optional[int]									=					MultiControlNetModel([controlneta, controlneta]     )

				_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 							__snake_case (		self      ,		_A      ,		_A=0     )    ->    Optional[int]:






				'''simple docstring'''







				if str(_A     ).startswith("""mps"""     ):
					_UpperCAmelCase    :							int									=					torch.manual_seed(_A     )
				else:
					_UpperCAmelCase    :							int									=					torch.Generator(device=_A     ).manual_seed(_A     )

				_UpperCAmelCase    :							str									=					2

				_UpperCAmelCase    :							List[str]									=					[
				    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     )      ,		),
				]
				_UpperCAmelCase    :							Optional[Any]									=					floats_tensor((1, 3, 32, 32)      ,		rng=random.Random(_A     )     ).to(_A     )
				_UpperCAmelCase    :							Tuple									=					init_image.cpu().permute(0      ,		2      ,		3      ,		1     )[0]

				_UpperCAmelCase    :							Union[str, Any]									=					Image.fromarray(np.uinta(_A     )     ).convert("""RGB"""     ).resize((64, 64)     )
				_UpperCAmelCase    :							Optional[Any]									=					Image.fromarray(np.uinta(init_image + 4     )     ).convert("""RGB"""     ).resize((64, 64)     )

				_UpperCAmelCase    :							List[str]									=					{
				    """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     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					self.get_dummy_components()
				_UpperCAmelCase    :							Dict									=					self.pipeline_class(**_A     )
				pipe.to(_A     )

				_UpperCAmelCase    :							Optional[Any]									=					10.0
				_UpperCAmelCase    :							str									=					4

				_UpperCAmelCase    :							Any									=					self.get_dummy_inputs(_A     )
				_UpperCAmelCase    :							Dict									=					steps
				_UpperCAmelCase    :							Any									=					scale
				_UpperCAmelCase    :							str									=					pipe(**_A     )[0]

				_UpperCAmelCase    :							Optional[int]									=					self.get_dummy_inputs(_A     )
				_UpperCAmelCase    :							List[Any]									=					steps
				_UpperCAmelCase    :							Union[str, Any]									=					scale
				_UpperCAmelCase    :							int									=					pipe(**_A      ,		control_guidance_start=0.1      ,		control_guidance_end=0.2     )[0]

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

				_UpperCAmelCase    :							Optional[int]									=					self.get_dummy_inputs(_A     )
				_UpperCAmelCase    :							Optional[Any]									=					steps
				_UpperCAmelCase    :							Optional[Any]									=					scale
				_UpperCAmelCase    :							Optional[int]									=					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     )    ->    int:






				'''simple docstring'''







				return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3     )
			@unittest.skipIf(
			    torch_device != """cuda""" or not is_xformers_available()      ,		reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,		)
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3     )
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







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






				'''simple docstring'''







				_UpperCAmelCase    :							str									=					self.get_dummy_components()
				_UpperCAmelCase    :							Tuple									=					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     _UpperCAmelCase			(		unittest.TestCase):
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							Dict									=					ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""     )

				_UpperCAmelCase    :							int									=					StableDiffusionControlNetInpaintPipeline.from_pretrained(
				    """runwayml/stable-diffusion-inpainting"""      ,		safety_checker=_A      ,		controlnet=_A     )
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=_A     )

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

				_UpperCAmelCase    :							Optional[int]									=					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    :							Dict									=					load_image(
				    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""     ).resize((5_12, 5_12)     )

				_UpperCAmelCase    :							int									=					pipe(
				    _A      ,		image=_A      ,		mask_image=_A      ,		control_image=_A      ,		generator=_A      ,		output_type="""np"""      ,		num_inference_steps=3      ,		)

				_UpperCAmelCase    :							Tuple									=					output.images[0]

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

				_UpperCAmelCase    :							Optional[Any]									=					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     )    ->    Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""     )

				_UpperCAmelCase    :							str									=					StableDiffusionControlNetInpaintPipeline.from_pretrained(
				    """runwayml/stable-diffusion-v1-5"""      ,		safety_checker=_A      ,		controlnet=_A     )
				_UpperCAmelCase    :							int									=					DDIMScheduler.from_config(pipe.scheduler.config     )
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=_A     )

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

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

				_UpperCAmelCase    :							List[Any]									=					load_image(
				    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""     )
				_UpperCAmelCase    :							Optional[int]									=					mask_image.resize((5_12, 5_12)     )

				_UpperCAmelCase    :							Tuple									=					"""a handsome man with ray-ban sunglasses"""

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

				_UpperCAmelCase    :							Optional[Any]									=					make_inpaint_condition(_A      ,		_A     )

				_UpperCAmelCase    :							Union[str, Any]									=					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"""      ,		)
				_UpperCAmelCase    :							Tuple									=					output.images[0]

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

				_UpperCAmelCase    :							Union[str, Any]									=					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_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase__				:  Union[str, Any]													=  {
    '''configuration_dpr''': ['''DPR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DPRConfig'''],
    '''tokenization_dpr''': [
        '''DPRContextEncoderTokenizer''',
        '''DPRQuestionEncoderTokenizer''',
        '''DPRReaderOutput''',
        '''DPRReaderTokenizer''',
    ],
}


try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  List[Any]													=  [
						    '''DPRContextEncoderTokenizerFast''',
						    '''DPRQuestionEncoderTokenizerFast''',
						    '''DPRReaderTokenizerFast''',
						]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  Dict													=  [
						    '''DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''DPRContextEncoder''',
						    '''DPRPretrainedContextEncoder''',
						    '''DPRPreTrainedModel''',
						    '''DPRPretrainedQuestionEncoder''',
						    '''DPRPretrainedReader''',
						    '''DPRQuestionEncoder''',
						    '''DPRReader''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  Any													=  [
						    '''TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFDPRContextEncoder''',
						    '''TFDPRPretrainedContextEncoder''',
						    '''TFDPRPretrainedQuestionEncoder''',
						    '''TFDPRPretrainedReader''',
						    '''TFDPRQuestionEncoder''',
						    '''TFDPRReader''',
						]


if TYPE_CHECKING:
						from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
						from .tokenization_dpr import (
						    DPRContextEncoderTokenizer,
						    DPRQuestionEncoderTokenizer,
						    DPRReaderOutput,
						    DPRReaderTokenizer,
						)

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_dpr_fast import (
												    DPRContextEncoderTokenizerFast,
												    DPRQuestionEncoderTokenizerFast,
												    DPRReaderTokenizerFast,
												)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_dpr import (
												    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DPRContextEncoder,
												    DPRPretrainedContextEncoder,
												    DPRPreTrainedModel,
												    DPRPretrainedQuestionEncoder,
												    DPRPretrainedReader,
												    DPRQuestionEncoder,
												    DPRReader,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_dpr import (
												    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFDPRContextEncoder,
												    TFDPRPretrainedContextEncoder,
												    TFDPRPretrainedQuestionEncoder,
												    TFDPRPretrainedReader,
												    TFDPRQuestionEncoder,
												    TFDPRReader,
												)

else:
						import sys

						lowerCamelCase__				:  Optional[Any]													=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





