
"""simple docstring"""






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



							'''simple docstring'''







							def __init__(    self     ,						_lowerCamelCase     ,						_lowerCamelCase=7     ,						_lowerCamelCase=3     ,						_lowerCamelCase=30     ,						_lowerCamelCase=400     ,						_lowerCamelCase=True     ,						_lowerCamelCase=None     ,						_lowerCamelCase=True     ,						_lowerCamelCase=[0.5, 0.5, 0.5]     ,						_lowerCamelCase=[0.5, 0.5, 0.5]     ,						_lowerCamelCase=False     ,						) ->       str:




										'''simple docstring'''
										__lowercase						      =					size if size is not None else {"height": 30, "width": 30}
										__lowercase						      =					parent
										__lowercase						      =					batch_size
										__lowercase						      =					num_channels
										__lowercase						      =					min_resolution
										__lowercase						      =					max_resolution
										__lowercase						      =					do_resize
										__lowercase						      =					size
										__lowercase						      =					do_normalize
										__lowercase						      =					image_mean
										__lowercase						      =					image_std
										__lowercase						      =					do_reduce_labels





							def      SCREAMING_SNAKE_CASE	(    self					) ->       Any:




										'''simple docstring'''
										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     lowerCAmelCase__ (		)	->Dict:
			__lowercase						      =					load_dataset("hf-internal-testing/fixtures_ade20k" ,      split="test"			)

			__lowercase						      =					Image.open(dataset[0]["file"]			)
			__lowercase						      =					Image.open(dataset[1]["file"]			)

			return image, map



def     lowerCAmelCase__ (		)	->List[Any]:
			__lowercase						      =					load_dataset("hf-internal-testing/fixtures_ade20k" ,      split="test"			)

			__lowercase						      =					Image.open(dataset[0]["file"]			)
			__lowercase						      =					Image.open(dataset[1]["file"]			)
			__lowercase						      =					Image.open(dataset[2]["file"]			)
			__lowercase						      =					Image.open(dataset[3]["file"]			)

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







@require_torch
@require_vision
class 				__a    (   __a				,      unittest.TestCase					):



							'''simple docstring'''







							_lowerCamelCase				: Dict					      =      SegformerImageProcessor if is_vision_available() else None
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[str]:




										'''simple docstring'''
										__lowercase						      =					SegformerImageProcessingTester(self					)
							@property
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Tuple:




										'''simple docstring'''
										return self.image_processor_tester.prepare_image_processor_dict()
							def      SCREAMING_SNAKE_CASE	(    self					) ->       str:




										'''simple docstring'''
										__lowercase						      =					self.image_processing_class(**self.image_processor_dict					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"do_resize"					)					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"size"					)					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"do_normalize"					)					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"image_mean"					)					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"image_std"					)					)
										self.assertTrue(hasattr(_lowerCamelCase     ,						"do_reduce_labels"					)					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[Any]:




										'''simple docstring'''
										__lowercase						      =					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     ,						_lowerCamelCase					)

										__lowercase						      =					self.image_processing_class.from_dict(self.image_processor_dict     ,						size=42     ,						reduce_labels=_lowerCamelCase					)
										self.assertEqual(image_processor.size     ,						{"height": 42, "width": 42}					)
										self.assertEqual(image_processor.do_reduce_labels     ,						_lowerCamelCase					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Union[str, Any]:




										'''simple docstring'''
										pass
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Dict:




										'''simple docstring'''
										# Initialize image_processing
										__lowercase						      =					self.image_processing_class(**self.image_processor_dict					)
										# create random PIL images
										__lowercase						      =					prepare_image_inputs(self.image_processor_tester     ,						equal_resolution=_lowerCamelCase					)
										for image in image_inputs:
													self.assertIsInstance(_lowerCamelCase     ,						Image.Image					)

										# Test not batched input
										__lowercase						      =					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
										__lowercase						      =					image_processing(_lowerCamelCase     ,						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      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[Any]:




										'''simple docstring'''
										# Initialize image_processing
										__lowercase						      =					self.image_processing_class(**self.image_processor_dict					)
										# create random numpy tensors
										__lowercase						      =					prepare_image_inputs(self.image_processor_tester     ,						equal_resolution=_lowerCamelCase     ,						numpify=_lowerCamelCase					)
										for image in image_inputs:
													self.assertIsInstance(_lowerCamelCase     ,						np.ndarray					)

										# Test not batched input
										__lowercase						      =					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
										__lowercase						      =					image_processing(_lowerCamelCase     ,						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      SCREAMING_SNAKE_CASE	(    self					) ->       int:




										'''simple docstring'''
										# Initialize image_processing
										__lowercase						      =					self.image_processing_class(**self.image_processor_dict					)
										# create random PyTorch tensors
										__lowercase						      =					prepare_image_inputs(self.image_processor_tester     ,						equal_resolution=_lowerCamelCase     ,						torchify=_lowerCamelCase					)
										for image in image_inputs:
													self.assertIsInstance(_lowerCamelCase     ,						torch.Tensor					)

										# Test not batched input
										__lowercase						      =					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
										__lowercase						      =					image_processing(_lowerCamelCase     ,						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      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										# Initialize image_processing
										__lowercase						      =					self.image_processing_class(**self.image_processor_dict					)
										# create random PyTorch tensors
										__lowercase						      =					prepare_image_inputs(self.image_processor_tester     ,						equal_resolution=_lowerCamelCase     ,						torchify=_lowerCamelCase					)
										__lowercase						      =					[]
										for image in image_inputs:
													self.assertIsInstance(_lowerCamelCase     ,						torch.Tensor					)
													maps.append(torch.zeros(image.shape[-2:]					).long()					)

										# Test not batched input
										__lowercase						      =					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
										__lowercase						      =					image_processing(_lowerCamelCase     ,						_lowerCamelCase     ,						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)
										__lowercase      ,				__lowercase						      =					prepare_semantic_single_inputs()

										__lowercase						      =					image_processing(_lowerCamelCase     ,						_lowerCamelCase     ,						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)
										__lowercase      ,				__lowercase						      =					prepare_semantic_batch_inputs()

										__lowercase						      =					image_processing(_lowerCamelCase     ,						_lowerCamelCase     ,						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      SCREAMING_SNAKE_CASE	(    self					) ->       List[Any]:




										'''simple docstring'''
										# Initialize image_processing
										__lowercase						      =					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
										__lowercase      ,				__lowercase						      =					prepare_semantic_single_inputs()
										__lowercase						      =					image_processing(_lowerCamelCase     ,						_lowerCamelCase     ,						return_tensors="pt"					)
										self.assertTrue(encoding["labels"].min().item() >= 0					)
										self.assertTrue(encoding["labels"].max().item() <= 150					)

										__lowercase						      =					True
										__lowercase						      =					image_processing(_lowerCamelCase     ,						_lowerCamelCase     ,						return_tensors="pt"					)
										self.assertTrue(encoding["labels"].min().item() >= 0					)
										self.assertTrue(encoding["labels"].max().item() <= 255					)







"""simple docstring"""






from scipy.constants import g



def     lowerCAmelCase__ (		__magic_name__ ,      __magic_name__			)	->float:
			if mass < 0:
						# handling of negative values of mass
						raise ValueError("The mass of a body cannot be negative"			)
			if height < 0:
						# handling of negative values of height
						raise ValueError("The height above the ground cannot be negative"			)
			return mass * g * height


if __name__ == "__main__":
					from doctest import testmod

					testmod(name='''potential_energy''')





