

# 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,
)


_lowerCAmelCase      :    int						       =    {
    "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:
						_lowerCAmelCase      :    Tuple						       =    ["DocumentQuestionAnsweringTool"]
						_lowerCAmelCase      :    List[Any]						       =    ["ImageCaptioningTool"]
						_lowerCAmelCase      :    Dict						       =    ["ImageQuestionAnsweringTool"]
						_lowerCAmelCase      :    Optional[Any]						       =    ["ImageSegmentationTool"]
						_lowerCAmelCase      :    Any						       =    ["SpeechToTextTool"]
						_lowerCAmelCase      :    Optional[Any]						       =    ["TextClassificationTool"]
						_lowerCAmelCase      :    str						       =    ["TextQuestionAnsweringTool"]
						_lowerCAmelCase      :    Any						       =    ["TextSummarizationTool"]
						_lowerCAmelCase      :    Any						       =    ["TextToSpeechTool"]
						_lowerCAmelCase      :    List[str]						       =    ["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

						_lowerCAmelCase      :    Union[str, Any]						       =    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)









import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


_lowerCAmelCase      :    List[str]						       =    False






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





			def 	__magic_name__					(	self      )     ->				Optional[Any]:




						'''simple docstring'''
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()





			def 	__magic_name__					(	self      )     ->				Tuple:




						'''simple docstring'''
						__a						   =VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'      )
						# remove text_unet
						pipe.remove_unused_weights()
						pipe.to(__snake_case      )
						pipe.set_progress_bar_config(disable=__snake_case      )

						__a						   =load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'      )

						__a						   =torch.manual_seed(0      )
						__a						   =pipe(
						    prompt='first prompt'      ,						image=__snake_case      ,						text_to_image_strength=0.75      ,						generator=__snake_case      ,						guidance_scale=7.5      ,						num_inference_steps=2      ,						output_type='numpy'      ,						).images

						with tempfile.TemporaryDirectory() as tmpdirname:
									pipe.save_pretrained(__snake_case      )
									__a						   =VersatileDiffusionDualGuidedPipeline.from_pretrained(__snake_case      )

						pipe.to(__snake_case      )
						pipe.set_progress_bar_config(disable=__snake_case      )

						__a						   =generator.manual_seed(0      )
						__a						   =pipe(
						    prompt='first prompt'      ,						image=__snake_case      ,						text_to_image_strength=0.75      ,						generator=__snake_case      ,						guidance_scale=7.5      ,						num_inference_steps=2      ,						output_type='numpy'      ,						).images

						assert np.abs(image - new_image      ).sum() < 1e-5, "Models don't have the same forward pass"





			def 	__magic_name__					(	self      )     ->				Optional[Any]:




						'''simple docstring'''
						__a						   =VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'      )
						pipe.remove_unused_weights()
						pipe.to(__snake_case      )
						pipe.set_progress_bar_config(disable=__snake_case      )

						__a						   ='cyberpunk 2077'
						__a						   =load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'      )
						__a						   =torch.manual_seed(0      )
						__a						   =pipe(
						    prompt=__snake_case      ,						image=__snake_case      ,						text_to_image_strength=0.75      ,						generator=__snake_case      ,						guidance_scale=7.5      ,						num_inference_steps=50      ,						output_type='numpy'      ,						).images

						__a						   =image[0, 253:256, 253:256, -1]

						assert image.shape == (1, 512, 512, 3)
						__a						   =np.array([0.0787, 0.0849, 0.0826, 0.0812, 0.0807, 0.0795, 0.0818, 0.0798, 0.0779]      )

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






