






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 ViTImageProcessor





class __lowerCamelCase			(				unittest.TestCase):





	"""simple docstring"""






	def __init__(							self	,   UpperCAmelCase	,   UpperCAmelCase=7	,   UpperCAmelCase=3	,   UpperCAmelCase=18	,   UpperCAmelCase=30	,   UpperCAmelCase=400	,   UpperCAmelCase=True	,   UpperCAmelCase=None	,   UpperCAmelCase=True	,   UpperCAmelCase=[0.5, 0.5, 0.5]	,   UpperCAmelCase=[0.5, 0.5, 0.5]	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      size if size is not None else {'height': 18, 'width': 18}
							_UpperCAmelCase     =      parent
							_UpperCAmelCase     =      batch_size
							_UpperCAmelCase     =      num_channels
							_UpperCAmelCase     =      image_size
							_UpperCAmelCase     =      min_resolution
							_UpperCAmelCase     =      max_resolution
							_UpperCAmelCase     =      do_resize
							_UpperCAmelCase     =      size
							_UpperCAmelCase     =      do_normalize
							_UpperCAmelCase     =      image_mean
							_UpperCAmelCase     =      image_std

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							return {
							    "image_mean": self.image_mean,
							    "image_std": self.image_std,
							    "do_normalize": self.do_normalize,
							    "do_resize": self.do_resize,
							    "size": self.size,
							}





@require_torch
@require_vision
class __lowerCamelCase			(				snake_case__					,	unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								=				ViTImageProcessor if is_vision_available() else None

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      ViTImageProcessingTester(self   )

	@property
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							return self.image_processor_tester.prepare_image_processor_dict()

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							self.assertTrue(hasattr(UpperCAmelCase	,   'image_mean'   )   )
							self.assertTrue(hasattr(UpperCAmelCase	,   'image_std'   )   )
							self.assertTrue(hasattr(UpperCAmelCase	,   'do_normalize'   )   )
							self.assertTrue(hasattr(UpperCAmelCase	,   'do_resize'   )   )
							self.assertTrue(hasattr(UpperCAmelCase	,   'size'   )   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.image_processing_class.from_dict(self.image_processor_dict   )
							self.assertEqual(image_processor.size	,   {'height': 18, 'width': 18}   )

							_UpperCAmelCase     =      self.image_processing_class.from_dict(self.image_processor_dict	,   size=42   )
							self.assertEqual(image_processor.size	,   {'height': 42, 'width': 42}   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							pass

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							# create random PIL images
							_UpperCAmelCase     =      prepare_image_inputs(self.image_processor_tester	,   equal_resolution=UpperCAmelCase   )
							for image in image_inputs:
													self.assertIsInstance(UpperCAmelCase	,   Image.Image   )

							# Test not batched input
							_UpperCAmelCase     =      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
							_UpperCAmelCase     =      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['height'],
							        self.image_processor_tester.size['width'],
							    )	,   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							# create random numpy tensors
							_UpperCAmelCase     =      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
							_UpperCAmelCase     =      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
							_UpperCAmelCase     =      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['height'],
							        self.image_processor_tester.size['width'],
							    )	,   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							# create random PyTorch tensors
							_UpperCAmelCase     =      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
							_UpperCAmelCase     =      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
							_UpperCAmelCase     =      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['height'],
							        self.image_processor_tester.size['width'],
							    )	,   )








import unittest
import warnings
from dataclasses import dataclass

from transformers.convert_slow_tokenizer import SpmConverter
from transformers.testing_utils import get_tests_dir





@dataclass
class __lowerCamelCase			:





	"""simple docstring"""






	UpperCamelCase__								=				42





class __lowerCamelCase			(				unittest.TestCase):





	"""simple docstring"""






	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      get_tests_dir('fixtures/test_sentencepiece.model'   )
							_UpperCAmelCase     =      get_tests_dir('fixtures/test_sentencepiece_with_bytefallback.model'   )

							_UpperCAmelCase     =      FakeOriginalTokenizer(vocab_file=UpperCAmelCase   )

							with warnings.catch_warnings(record=UpperCAmelCase   ) as w:
													_UpperCAmelCase     =      SpmConverter(UpperCAmelCase   )
							self.assertEqual(len(UpperCAmelCase   )	,   0   )

							_UpperCAmelCase     =      FakeOriginalTokenizer(vocab_file=UpperCAmelCase   )

							with warnings.catch_warnings(record=UpperCAmelCase   ) as w:
													_UpperCAmelCase     =      SpmConverter(UpperCAmelCase   )
							self.assertEqual(len(UpperCAmelCase   )	,   1   )

							self.assertIn(
							    'The sentencepiece tokenizer that you are converting to a fast tokenizer uses the byte fallback option'
							    ' which is not implemented in the fast tokenizers.'	,   str(w[0].message   )	,   )
