





import unittest

import numpy as np

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 ConvNextImageProcessor

class 					__A   (  unittest.TestCase			):


				def __init__(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_=7      ,       UpperCAmelCase_=3      ,       UpperCAmelCase_=18      ,       UpperCAmelCase_=30      ,       UpperCAmelCase_=400      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=None      ,       UpperCAmelCase_=0.8_7_5      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=[0.5, 0.5, 0.5]      ,       UpperCAmelCase_=[0.5, 0.5, 0.5]      ,       ):
								lowerCamelCase		       =size if size is not None else {"""shortest_edge""": 20}
								lowerCamelCase		       =parent
								lowerCamelCase		       =batch_size
								lowerCamelCase		       =num_channels
								lowerCamelCase		       =image_size
								lowerCamelCase		       =min_resolution
								lowerCamelCase		       =max_resolution
								lowerCamelCase		       =do_resize
								lowerCamelCase		       =size
								lowerCamelCase		       =crop_pct
								lowerCamelCase		       =do_normalize
								lowerCamelCase		       =image_mean
								lowerCamelCase		       =image_std


				def _snake_case				(						self							):
								return {
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								    "do_normalize": self.do_normalize,
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "crop_pct": self.crop_pct,
								}




@require_torch
@require_vision
class 					__A   (  a			,    unittest.TestCase			):
				__A            = ConvNextImageProcessor if is_vision_available() else None


				def _snake_case				(						self							):
								lowerCamelCase		       =ConvNextImageProcessingTester(self							)


				@property
				def _snake_case				(						self							):
								return self.image_processor_tester.prepare_image_processor_dict()


				def _snake_case				(						self							):
								lowerCamelCase		       =self.image_processing_class(**self.image_processor_dict							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """do_resize"""							)							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """size"""							)							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """crop_pct"""							)							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """do_normalize"""							)							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """image_mean"""							)							)
								self.assertTrue(hasattr(UpperCAmelCase_      ,       """image_std"""							)							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.image_processing_class.from_dict(self.image_processor_dict							)
								self.assertEqual(image_processor.size      ,       {"""shortest_edge""": 20}							)

								lowerCamelCase		       =self.image_processing_class.from_dict(self.image_processor_dict      ,       size=42							)
								self.assertEqual(image_processor.size      ,       {"""shortest_edge""": 42}							)


				def _snake_case				(						self							):
								pass


				def _snake_case				(						self							):
								# Initialize image_processing
								lowerCamelCase		       =self.image_processing_class(**self.image_processor_dict							)
								# create random PIL images
								lowerCamelCase		       =prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=UpperCAmelCase_							)
								for image in image_inputs:
												self.assertIsInstance(UpperCAmelCase_      ,       Image.Image							)

								# Test not batched input
								lowerCamelCase		       =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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )

								# Test batched
								lowerCamelCase		       =image_processing(UpperCAmelCase_      ,       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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )


				def _snake_case				(						self							):
								# Initialize image_processing
								lowerCamelCase		       =self.image_processing_class(**self.image_processor_dict							)
								# create random numpy tensors
								lowerCamelCase		       =prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=UpperCAmelCase_      ,       numpify=UpperCAmelCase_							)
								for image in image_inputs:
												self.assertIsInstance(UpperCAmelCase_      ,       np.ndarray							)

								# Test not batched input
								lowerCamelCase		       =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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )

								# Test batched
								lowerCamelCase		       =image_processing(UpperCAmelCase_      ,       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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )


				def _snake_case				(						self							):
								# Initialize image_processing
								lowerCamelCase		       =self.image_processing_class(**self.image_processor_dict							)
								# create random PyTorch tensors
								lowerCamelCase		       =prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=UpperCAmelCase_      ,       torchify=UpperCAmelCase_							)
								for image in image_inputs:
												self.assertIsInstance(UpperCAmelCase_      ,       torch.Tensor							)

								# Test not batched input
								lowerCamelCase		       =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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )

								# Test batched
								lowerCamelCase		       =image_processing(UpperCAmelCase_      ,       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["""shortest_edge"""],
								        self.image_processor_tester.size["""shortest_edge"""],
								    )      ,       )












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase__  :	Optional[Any]     ={'''configuration_pegasus''': ['''PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusConfig''']}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  :	Union[str, Any]     =['''PegasusTokenizer''']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  :	int     =['''PegasusTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  :	str     =[
							    '''PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''PegasusForCausalLM''',
							    '''PegasusForConditionalGeneration''',
							    '''PegasusModel''',
							    '''PegasusPreTrainedModel''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  :	Union[str, Any]     =[
							    '''TFPegasusForConditionalGeneration''',
							    '''TFPegasusModel''',
							    '''TFPegasusPreTrainedModel''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  :	Dict     =[
							    '''FlaxPegasusForConditionalGeneration''',
							    '''FlaxPegasusModel''',
							    '''FlaxPegasusPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_pegasus import PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_pegasus import PegasusTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_pegasus_fast import PegasusTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_pegasus import (
														    PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
														    PegasusForCausalLM,
														    PegasusForConditionalGeneration,
														    PegasusModel,
														    PegasusPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_pegasus import TFPegasusForConditionalGeneration, TFPegasusModel, TFPegasusPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_pegasus import (
														    FlaxPegasusForConditionalGeneration,
														    FlaxPegasusModel,
														    FlaxPegasusPreTrainedModel,
														)

else:
							import sys

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





