# 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__	:  Optional[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__	:  Optional[int]						=  ['DocumentQuestionAnsweringTool']
				lowerCAmelCase__	:  Optional[Any]						=  ['ImageCaptioningTool']
				lowerCAmelCase__	:  Any						=  ['ImageQuestionAnsweringTool']
				lowerCAmelCase__	:  str						=  ['ImageSegmentationTool']
				lowerCAmelCase__	:  int						=  ['SpeechToTextTool']
				lowerCAmelCase__	:  str						=  ['TextClassificationTool']
				lowerCAmelCase__	:  List[Any]						=  ['TextQuestionAnsweringTool']
				lowerCAmelCase__	:  Any						=  ['TextSummarizationTool']
				lowerCAmelCase__	:  str						=  ['TextToSpeechTool']
				lowerCAmelCase__	:  Tuple						=  ['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__	:  Tuple						=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)







import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import SegformerImageProcessor




class 				lowerCAmelCase__	(						unittest.TestCase    ):







					def __init__(							self   :  int      ,		_A   :  Optional[Any]      ,		_A   :  Optional[int]=7      ,		_A   :  str=3      ,		_A   :  Optional[int]=30      ,		_A   :  List[str]=400      ,		_A   :  Tuple=True      ,		_A   :  List[Any]=None      ,		_A   :  Dict=True      ,		_A   :  Tuple=[0.5, 0.5, 0.5]      ,		_A   :  List[str]=[0.5, 0.5, 0.5]      ,		_A   :  int=False      ,		):
											A__						:				Tuple         =			size if size is not None else {"height": 30, "width": 30}
											A__						:				Tuple         =			parent
											A__						:				str         =			batch_size
											A__						:				int         =			num_channels
											A__						:				Union[str, Any]         =			min_resolution
											A__						:				List[str]         =			max_resolution
											A__						:				int         =			do_resize
											A__						:				Tuple         =			size
											A__						:				Union[str, Any]         =			do_normalize
											A__						:				Optional[int]         =			image_mean
											A__						:				List[Any]         =			image_std
											A__						:				Dict         =			do_reduce_labels







					def 			_lowercase      (							self   :  Optional[int]):
											return {
											    "do_resize": self.do_resize,
											    "size": self.size,
											    "do_normalize": self.do_normalize,
											    "image_mean": self.image_mean,
											    "image_std": self.image_std,
											    "do_reduce_labels": self.do_reduce_labels,
											}




def 						snake_case__							(       )		->		Tuple:







						"""simple docstring"""

						A__						:				Union[str, Any]         =			load_dataset("hf-internal-testing/fixtures_ade20k"				,  split="test"							)

						A__						:				Any         =			Image.open(dataset[0]["file"]							)
						A__						:				Any         =			Image.open(dataset[1]["file"]							)

						return image, map
def 						snake_case__							(       )		->		List[str]:







						"""simple docstring"""

						A__						:				Tuple         =			load_dataset("hf-internal-testing/fixtures_ade20k"				,  split="test"							)

						A__						:				Tuple         =			Image.open(dataset[0]["file"]							)
						A__						:				int         =			Image.open(dataset[1]["file"]							)
						A__						:				str         =			Image.open(dataset[2]["file"]							)
						A__						:				List[Any]         =			Image.open(dataset[3]["file"]							)

						return [imagea, imagea], [mapa, mapa]




@require_torch
@require_vision
class 				lowerCAmelCase__	(						UpperCamelCase       ,				unittest.TestCase    ):
					__A  :     int     =    SegformerImageProcessor if is_vision_available() else None







					def 			_lowercase      (							self   :  int):
											A__						:				int         =			SegformerImageProcessingTester(self)







					@property
					def 			_lowercase      (							self   :  str):
											return self.image_processor_tester.prepare_image_processor_dict()







					def 			_lowercase      (							self   :  Optional[Any]):
											A__						:				Any         =			self.image_processing_class(**self.image_processor_dict)
											self.assertTrue(hasattr(_A      ,		"do_resize"))
											self.assertTrue(hasattr(_A      ,		"size"))
											self.assertTrue(hasattr(_A      ,		"do_normalize"))
											self.assertTrue(hasattr(_A      ,		"image_mean"))
											self.assertTrue(hasattr(_A      ,		"image_std"))
											self.assertTrue(hasattr(_A      ,		"do_reduce_labels"))







					def 			_lowercase      (							self   :  Tuple):
											A__						:				Union[str, Any]         =			self.image_processing_class.from_dict(self.image_processor_dict)
											self.assertEqual(image_processor.size      ,		{"height": 30, "width": 30})
											self.assertEqual(image_processor.do_reduce_labels      ,		_A)

											A__						:				Union[str, Any]         =			self.image_processing_class.from_dict(self.image_processor_dict      ,		size=42      ,		reduce_labels=_A)
											self.assertEqual(image_processor.size      ,		{"height": 42, "width": 42})
											self.assertEqual(image_processor.do_reduce_labels      ,		_A)







					def 			_lowercase      (							self   :  Union[str, Any]):
											pass







					def 			_lowercase      (							self   :  Dict):
											# Initialize image_processing
											A__						:				Tuple         =			self.image_processing_class(**self.image_processor_dict)
											# create random PIL images
											A__						:				Union[str, Any]         =			prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A)
											for image in image_inputs:
																	self.assertIsInstance(_A      ,		Image.Image)

											# Test not batched input
											A__						:				Dict         =			image_processing(image_inputs[0]      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)

											# Test batched
											A__						:				List[Any]         =			image_processing(_A      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)







					def 			_lowercase      (							self   :  Optional[int]):
											# Initialize image_processing
											A__						:				Tuple         =			self.image_processing_class(**self.image_processor_dict)
											# create random numpy tensors
											A__						:				Tuple         =			prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A      ,		numpify=_A)
											for image in image_inputs:
																	self.assertIsInstance(_A      ,		np.ndarray)

											# Test not batched input
											A__						:				Optional[Any]         =			image_processing(image_inputs[0]      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)

											# Test batched
											A__						:				Optional[int]         =			image_processing(_A      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)







					def 			_lowercase      (							self   :  Tuple):
											# Initialize image_processing
											A__						:				str         =			self.image_processing_class(**self.image_processor_dict)
											# create random PyTorch tensors
											A__						:				str         =			prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A      ,		torchify=_A)
											for image in image_inputs:
																	self.assertIsInstance(_A      ,		torch.Tensor)

											# Test not batched input
											A__						:				int         =			image_processing(image_inputs[0]      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)

											# Test batched
											A__						:				List[str]         =			image_processing(_A      ,		return_tensors="pt").pixel_values
											self.assertEqual(
											    encoded_images.shape      ,		(
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)







					def 			_lowercase      (							self   :  Optional[int]):
											# Initialize image_processing
											A__						:				str         =			self.image_processing_class(**self.image_processor_dict)
											# create random PyTorch tensors
											A__						:				Optional[Any]         =			prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A      ,		torchify=_A)
											A__						:				List[str]         =			[]
											for image in image_inputs:
																	self.assertIsInstance(_A      ,		torch.Tensor)
																	maps.append(torch.zeros(image.shape[-2:]).long())

											# Test not batched input
											A__						:				Any         =			image_processing(image_inputs[0]      ,		maps[0]      ,		return_tensors="pt")
											self.assertEqual(
											    encoding["pixel_values"].shape      ,		(
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(
											    encoding["labels"].shape      ,		(
											        1,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(encoding["labels"].dtype      ,		torch.long)
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 255)

											# Test batched
											A__						:				int         =			image_processing(_A      ,		_A      ,		return_tensors="pt")
											self.assertEqual(
											    encoding["pixel_values"].shape      ,		(
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(
											    encoding["labels"].shape      ,		(
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(encoding["labels"].dtype      ,		torch.long)
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 255)

											# Test not batched input (PIL images)
											A__     ,							A__						:				List[str]         =			prepare_semantic_single_inputs()

											A__						:				Any         =			image_processing(_A      ,		_A      ,		return_tensors="pt")
											self.assertEqual(
											    encoding["pixel_values"].shape      ,		(
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(
											    encoding["labels"].shape      ,		(
											        1,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(encoding["labels"].dtype      ,		torch.long)
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 255)

											# Test batched input (PIL images)
											A__     ,							A__						:				Union[str, Any]         =			prepare_semantic_batch_inputs()

											A__						:				str         =			image_processing(_A      ,		_A      ,		return_tensors="pt")
											self.assertEqual(
											    encoding["pixel_values"].shape      ,		(
											        2,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(
											    encoding["labels"].shape      ,		(
											        2,
											        self.image_processor_tester.size["height"],
											        self.image_processor_tester.size["width"],
											    )      ,		)
											self.assertEqual(encoding["labels"].dtype      ,		torch.long)
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 255)







					def 			_lowercase      (							self   :  Union[str, Any]):
											# Initialize image_processing
											A__						:				List[str]         =			self.image_processing_class(**self.image_processor_dict)

											# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
											A__     ,							A__						:				Tuple         =			prepare_semantic_single_inputs()
											A__						:				Dict         =			image_processing(_A      ,		_A      ,		return_tensors="pt")
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 150)

											A__						:				str         =			True
											A__						:				int         =			image_processing(_A      ,		_A      ,		return_tensors="pt")
											self.assertTrue(encoding["labels"].min().item() >= 0)
											self.assertTrue(encoding["labels"].max().item() <= 255)