




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCamelCase     =				{
    '''configuration_musicgen''': [
        '''MUSICGEN_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''MusicgenConfig''',
        '''MusicgenDecoderConfig''',
    ],
    '''processing_musicgen''': ['''MusicgenProcessor'''],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase     =				[
         '''MUSICGEN_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''MusicgenForConditionalGeneration''',
         '''MusicgenForCausalLM''',
         '''MusicgenModel''',
         '''MusicgenPreTrainedModel''',
     ]

if TYPE_CHECKING:
     from .configuration_musicgen import (
         MUSICGEN_PRETRAINED_CONFIG_ARCHIVE_MAP,
         MusicgenConfig,
         MusicgenDecoderConfig,
     )
     from .processing_musicgen import MusicgenProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_musicgen import (
              MUSICGEN_PRETRAINED_MODEL_ARCHIVE_LIST,
              MusicgenForCausalLM,
              MusicgenForConditionalGeneration,
              MusicgenModel,
              MusicgenPreTrainedModel,
          )

else:
     import sys

     UpperCamelCase     =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)












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







  '''simple docstring'''

  def __init__(   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Any=7				,     SCREAMING_SNAKE_CASE_							:       Dict=3				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=30				,     SCREAMING_SNAKE_CASE_							:       List[Any]=4_00				,     SCREAMING_SNAKE_CASE_							:       str=True				,     SCREAMING_SNAKE_CASE_							:       List[Any]=None				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=True				,     SCREAMING_SNAKE_CASE_							:       List[str]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Tuple=False				,     ) ->		str:







       '''simple docstring'''



       A:		Dict        =		size if size is not None else {'''height''': 30, '''width''': 30}
       A:		List[Any]        =		parent
       A:		Tuple        =		batch_size
       A:		List[str]        =		num_channels
       A:		Dict        =		min_resolution
       A:		str        =		max_resolution
       A:		int        =		do_resize
       A:		List[str]        =		size
       A:		int        =		do_normalize
       A:		Optional[int]        =		image_mean
       A:		Optional[int]        =		image_std
       A:		Any        =		do_reduce_labels




  def 				_snake_case    (   self							:       Any  ) ->		List[str]:







       '''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 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Dict        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Any        =		Image.open(dataset[0]['''file''']  )
     A:		Dict        =		Image.open(dataset[1]['''file''']  )

     return image, map
def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Optional[Any]        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Union[str, Any]        =		Image.open(dataset[0]['''file''']  )
     A:		str        =		Image.open(dataset[1]['''file''']  )
     A:		str        =		Image.open(dataset[2]['''file''']  )
     A:		Any        =		Image.open(dataset[3]['''file''']  )

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






@require_torch
@require_vision
class 	lowerCAmelCase_  (					UpperCAmelCase_					,				unittest.TestCase       ):







  '''simple docstring'''

  UpperCamelCase_ :			int        =							SegformerImageProcessor if is_vision_available() else None



  def 				_snake_case    (   self							:       List[str]  ) ->		str:







       '''simple docstring'''



       A:		Dict        =		SegformerImageProcessingTester(self  )



  @property
  def 				_snake_case    (   self							:       Tuple  ) ->		List[str]:







       '''simple docstring'''



       return self.image_processor_tester.prepare_image_processor_dict()



  def 				_snake_case    (   self							:       Optional[int]  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_resize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''size'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_normalize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_mean'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_std'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_reduce_labels'''  )  )



  def 				_snake_case    (   self							:       List[str]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Tuple        =		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				,     SCREAMING_SNAKE_CASE_  )

       A:		str        =		self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     reduce_labels=SCREAMING_SNAKE_CASE_  )
       self.assertEqual(image_processor.size				,     {'''height''': 42, '''width''': 42}  )
       self.assertEqual(image_processor.do_reduce_labels				,     SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       Union[str, Any]  ) ->		Any:







       '''simple docstring'''



       pass



  def 				_snake_case    (   self							:       Any  ) ->		Dict:







       '''simple docstring'''



       A:		Dict        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     Image.Image  )

       # Test not batched input
       A:		List[str]        =		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:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       str  ) ->		Tuple:







       '''simple docstring'''



       A:		int        =		self.image_processing_class(**self.image_processor_dict  )
       # create random numpy tensors
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     numpify=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     np.ndarray  )

       # 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:		Any        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       str  ) ->		str:







       '''simple docstring'''



       A:		List[Any]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		str        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     torchify=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     torch.Tensor  )

       # Test not batched input
       A:		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:		List[Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       Dict  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		Optional[int]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     torchify=SCREAMING_SNAKE_CASE_  )
       A:		Optional[Any]        =		[]
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     torch.Tensor  )
            maps.append(torch.zeros(image.shape[-2:]  ).long()  )

       # Test not batched input
       A:		Tuple        =		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() <= 2_55  )

       # Test batched
       A:		Union[str, Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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() <= 2_55  )

       # Test not batched input (PIL images)
       A    ,						A:		int        =		prepare_semantic_single_inputs()

       A:		Dict        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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() <= 2_55  )

       # Test batched input (PIL images)
       A    ,						A:		int        =		prepare_semantic_batch_inputs()

       A:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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() <= 2_55  )




  def 				_snake_case    (   self							:       Tuple  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Any        =		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:		Union[str, Any]        =		prepare_semantic_single_inputs()
       A:		Optional[int]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 1_50  )

       A:		Optional[int]        =		True
       A:		str        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )






