






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


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import CLIPImageProcessor





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=None	,   UpperCAmelCase=True	,   UpperCAmelCase=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]	,   UpperCAmelCase=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]	,   UpperCAmelCase=True	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      size if size is not None else {'shortest_edge': 20}
							_UpperCAmelCase     =      crop_size if crop_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_center_crop
							_UpperCAmelCase     =      crop_size
							_UpperCAmelCase     =      do_normalize
							_UpperCAmelCase     =      image_mean
							_UpperCAmelCase     =      image_std
							_UpperCAmelCase     =      do_convert_rgb

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







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

	def 	UpperCamelCase   (							self	,   UpperCAmelCase=False	,   UpperCAmelCase=False	,   UpperCAmelCase=False   ):
							"""simple docstring"""







							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

							if equal_resolution:
													_UpperCAmelCase     =      []
													for i in range(self.batch_size   ):
																			image_inputs.append(
																			    np.random.randint(
																			        255	,   size=(self.num_channels, self.max_resolution, self.max_resolution)	,   dtype=np.uinta   )   )
							else:
													_UpperCAmelCase     =      []
													for i in range(self.batch_size   ):
																			_UpperCAmelCase ,			_UpperCAmelCase     =      np.random.choice(np.arange(self.min_resolution	,   self.max_resolution   )	,   2   )
																			image_inputs.append(np.random.randint(255	,   size=(self.num_channels, width, height)	,   dtype=np.uinta   )   )

							if not numpify and not torchify:
													# PIL expects the channel dimension as last dimension
													_UpperCAmelCase     =      [Image.fromarray(np.moveaxis(lowerCAmelCase__	,   0	,   -1   )   ) for x in image_inputs]

							if torchify:
													_UpperCAmelCase     =      [torch.from_numpy(lowerCAmelCase__   ) for x in image_inputs]

							return image_inputs





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





	"""simple docstring"""






	UpperCamelCase__								=				CLIPImageProcessor if is_vision_available() else None

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







							_UpperCAmelCase     =      CLIPImageProcessingTester(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(lowerCAmelCase__	,   'do_resize'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'size'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_center_crop'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'center_crop'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_normalize'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'image_mean'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'image_std'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_convert_rgb'   )   )

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







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

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

	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     =      self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__   )
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__	,   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.crop_size['height'],
							        self.image_processor_tester.crop_size['width'],
							    )	,   )

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

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







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							# create random numpy tensors
							_UpperCAmelCase     =      self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__	,   numpify=lowerCAmelCase__   )
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__	,   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.crop_size['height'],
							        self.image_processor_tester.crop_size['width'],
							    )	,   )

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

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







							_UpperCAmelCase     =      self.image_processing_class(**self.image_processor_dict   )
							# create random PyTorch tensors
							_UpperCAmelCase     =      self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__	,   torchify=lowerCAmelCase__   )
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__	,   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.crop_size['height'],
							        self.image_processor_tester.crop_size['width'],
							    )	,   )

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





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





	"""simple docstring"""






	UpperCamelCase__								=				CLIPImageProcessor if is_vision_available() else None

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







							_UpperCAmelCase     =      CLIPImageProcessingTester(self	,   num_channels=4   )
							_UpperCAmelCase     =      3

	@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(lowerCAmelCase__	,   'do_resize'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'size'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_center_crop'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'center_crop'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_normalize'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'image_mean'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'image_std'   )   )
							self.assertTrue(hasattr(lowerCAmelCase__	,   'do_convert_rgb'   )   )

	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     =      self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__   )
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__	,   Image.Image   )

							# Test not batched input
							_UpperCAmelCase     =      image_processing(image_inputs[0]	,   return_tensors='pt'   ).pixel_values
							self.assertEqual(
							    encoded_images.shape	,   (
							        1,
							        self.expected_encoded_image_num_channels,
							        self.image_processor_tester.crop_size['height'],
							        self.image_processor_tester.crop_size['width'],
							    )	,   )

							# Test batched
							_UpperCAmelCase     =      image_processing(lowerCAmelCase__	,   return_tensors='pt'   ).pixel_values
							self.assertEqual(
							    encoded_images.shape	,   (
							        self.image_processor_tester.batch_size,
							        self.expected_encoded_image_num_channels,
							        self.image_processor_tester.crop_size['height'],
							        self.image_processor_tester.crop_size['width'],
							    )	,   )








from ..utils import DummyObject, requires_backends





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )
