



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






			"""simple docstring"""





			lowercase__   :	Tuple  			=      StableDiffusionControlNetInpaintPipeline
			lowercase__   :	Any  			=      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			lowercase__   :	List[str]  			=      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			lowercase__   :	Any  			=      frozenset({"""control_image"""}      )  # skip `image` and `mask` for now, only test for control_image
			lowercase__   :	List[str]  			=      TEXT_TO_IMAGE_IMAGE_PARAMS





			def 		snake_case__      (					self						:							List[str] )    ->       int:
									"""simple docstring"""







									torch.manual_seed(0 )
									__lowercase											=					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 )
									__lowercase											=					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 )
									__lowercase											=					DDIMScheduler(
									    beta_start=0.0_0085      ,  beta_end=0.012      ,  beta_schedule="""scaled_linear"""      ,  clip_sample=lowercase      ,  set_alpha_to_one=lowercase      ,  )
									torch.manual_seed(0 )
									__lowercase											=					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 )
									__lowercase											=					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      ,  )
									__lowercase											=					CLIPTextModel(lowercase )
									__lowercase											=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

									__lowercase											=					{
									    """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						:							int      ,  lowercase						:							Any      ,  lowercase						:							str=0 )    ->       str:
									"""simple docstring"""







									if str(lowercase ).startswith("""mps""" ):
															__lowercase											=					torch.manual_seed(lowercase )
									else:
															__lowercase											=					torch.Generator(device=lowercase ).manual_seed(lowercase )

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

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

									__lowercase											=					{
									    """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 )    ->       List[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 )    ->       Optional[int]:
									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 )







			def 		snake_case__      (					self						:							Optional[Any] )    ->       Dict:
									"""simple docstring"""







									self._test_inference_batch_single_identical(expected_max_diff=2E-3 )





class       _lowerCAmelCase (			_UpperCAmelCase      ):






			"""simple docstring"""





			lowercase__   :	Optional[int]  			=      StableDiffusionControlNetInpaintPipeline
			lowercase__   :	Any  			=      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			lowercase__   :	int  			=      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			lowercase__   :	Union[str, Any]  			=      frozenset([]      )





			def 		snake_case__      (					self						:							Optional[int] )    ->       List[str]:
									"""simple docstring"""







									torch.manual_seed(0 )
									__lowercase											=					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 )
									__lowercase											=					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 )
									__lowercase											=					DDIMScheduler(
									    beta_start=0.0_0085      ,  beta_end=0.012      ,  beta_schedule="""scaled_linear"""      ,  clip_sample=lowercase      ,  set_alpha_to_one=lowercase      ,  )
									torch.manual_seed(0 )
									__lowercase											=					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 )
									__lowercase											=					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      ,  )
									__lowercase											=					CLIPTextModel(lowercase )
									__lowercase											=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

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





class       _lowerCAmelCase (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase      ):






			"""simple docstring"""





			lowercase__   :	List[str]  			=      StableDiffusionControlNetInpaintPipeline
			lowercase__   :	List[Any]  			=      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			lowercase__   :	List[str]  			=      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS





			def 		snake_case__      (					self						:							Optional[int] )    ->       int:
									"""simple docstring"""







									torch.manual_seed(0 )
									__lowercase											=					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						:							List[Any] ):
															if isinstance(lowercase      ,  torch.nn.Convad ):
																					torch.nn.init.normal(m.weight )
																					m.bias.data.fill_(1.0 )

									__lowercase											=					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 )
									__lowercase											=					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 )
									__lowercase											=					DDIMScheduler(
									    beta_start=0.0_0085      ,  beta_end=0.012      ,  beta_schedule="""scaled_linear"""      ,  clip_sample=lowercase      ,  set_alpha_to_one=lowercase      ,  )
									torch.manual_seed(0 )
									__lowercase											=					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 )
									__lowercase											=					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      ,  )
									__lowercase											=					CLIPTextModel(lowercase )
									__lowercase											=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

									__lowercase											=					MultiControlNetModel([controlneta, controlneta] )

									__lowercase											=					{
									    """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						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Union[str, Any]=0 )    ->       Any:
									"""simple docstring"""







									if str(lowercase ).startswith("""mps""" ):
															__lowercase											=					torch.manual_seed(lowercase )
									else:
															__lowercase											=					torch.Generator(device=lowercase ).manual_seed(lowercase )

									__lowercase											=					2

									__lowercase											=					[
									    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 )      ,  ),
									]
									__lowercase											=					floats_tensor((1, 3, 32, 32)      ,  rng=random.Random(lowercase ) ).to(lowercase )
									__lowercase											=					init_image.cpu().permute(0      ,  2      ,  3      ,  1 )[0]

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

									__lowercase											=					{
									    """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						:							List[str] )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					self.get_dummy_components()
									__lowercase											=					self.pipeline_class(**lowercase )
									pipe.to(lowercase )

									__lowercase											=					10.0
									__lowercase											=					4

									__lowercase											=					self.get_dummy_inputs(lowercase )
									__lowercase											=					steps
									__lowercase											=					scale
									__lowercase											=					pipe(**lowercase )[0]

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

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

									__lowercase											=					self.get_dummy_inputs(lowercase )
									__lowercase											=					steps
									__lowercase											=					scale
									__lowercase											=					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 		snake_case__      (					self						:							Dict )    ->       Dict:
									"""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						:							Any )    ->       int:
									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       Optional[int]:
									"""simple docstring"""







									self._test_inference_batch_single_identical(expected_max_diff=2E-3 )







			def 		snake_case__      (					self						:							int )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.get_dummy_components()
									__lowercase											=					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       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			def 		snake_case__      (					self						:							List[Any] )    ->       Dict:
									"""simple docstring"""







									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()





			def 		snake_case__      (					self						:							str )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny""" )

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

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

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

									__lowercase											=					"""pitch black hole"""

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

									__lowercase											=					pipe(
									    lowercase      ,  image=lowercase      ,  mask_image=lowercase      ,  control_image=lowercase      ,  generator=lowercase      ,  output_type="""np"""      ,  num_inference_steps=3      ,  )

									__lowercase											=					output.images[0]

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

									__lowercase											=					load_numpy(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy""" )

									assert np.abs(expected_image - image ).max() < 9E-2







			def 		snake_case__      (					self						:							int )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint""" )

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

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

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

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

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

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

									__lowercase											=					make_inpaint_condition(lowercase      ,  lowercase )

									__lowercase											=					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"""      ,  )
									__lowercase											=					output.images[0]

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

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










# Copyright 2023 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 typing import TYPE_CHECKING

from ..utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCamelCase__			=    {
    "agents": ["Agent", "AzureOpenAiAgent", "HfAgent", "LocalAgent", "OpenAiAgent"],
    "base": ["PipelineTool", "RemoteTool", "Tool", "launch_gradio_demo", "load_tool"],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCamelCase__			=    ["DocumentQuestionAnsweringTool"]
			UpperCamelCase__			=    ["ImageCaptioningTool"]
			UpperCamelCase__			=    ["ImageQuestionAnsweringTool"]
			UpperCamelCase__			=    ["ImageSegmentationTool"]
			UpperCamelCase__			=    ["SpeechToTextTool"]
			UpperCamelCase__			=    ["TextClassificationTool"]
			UpperCamelCase__			=    ["TextQuestionAnsweringTool"]
			UpperCamelCase__			=    ["TextSummarizationTool"]
			UpperCamelCase__			=    ["TextToSpeechTool"]
			UpperCamelCase__			=    ["TranslationTool"]

if TYPE_CHECKING:
			from .agents import Agent, AzureOpenAiAgent, HfAgent, LocalAgent, OpenAiAgent
			from .base import PipelineTool, RemoteTool, Tool, launch_gradio_demo, load_tool

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .document_question_answering import DocumentQuestionAnsweringTool
						from .image_captioning import ImageCaptioningTool
						from .image_question_answering import ImageQuestionAnsweringTool
						from .image_segmentation import ImageSegmentationTool
						from .speech_to_text import SpeechToTextTool
						from .text_classification import TextClassificationTool
						from .text_question_answering import TextQuestionAnsweringTool
						from .text_summarization import TextSummarizationTool
						from .text_to_speech import TextToSpeechTool
						from .translation import TranslationTool
else:
			import sys

			UpperCamelCase__			=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





