




import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin







class        __lowerCAmelCase					(			__magic_name__     ,							unittest.TestCase					):

			"""simple docstring"""







			snake_case_  						=			CanineTokenizer
			snake_case_  						=			False


			def  lowercase_       ( self				)       -> Optional[Any]:



							'''simple docstring'''
							super().setUp()
							__lowerCamelCase									=       CanineTokenizer()
							tokenizer.save_pretrained(self.tmpdirname				)


			@cached_property
			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							return CanineTokenizer.from_pretrained('google/canine-s'				)


			def  lowercase_       ( self     ,		**lowerCamelCase__				)       -> CanineTokenizer:



							'''simple docstring'''
							__lowerCamelCase									=       self.tokenizer_class.from_pretrained(self.tmpdirname     ,		**lowerCamelCase__				)
							__lowerCamelCase									=       1_024
							return tokenizer


			@require_torch
			def  lowercase_       ( self				)       -> Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.canine_tokenizer
							__lowerCamelCase									=       ['Life is like a box of chocolates.', 'You never know what you\'re gonna get.']
							# fmt: off
							__lowerCamelCase									=       [57_344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57_345, 0, 0, 0, 0]
							# fmt: on
							__lowerCamelCase									=       tokenizer(lowerCamelCase__     ,		padding=lowerCamelCase__     ,		return_tensors='pt'				)
							self.assertIsInstance(lowerCamelCase__     ,		lowerCamelCase__				)

							__lowerCamelCase									=       list(batch.input_ids.numpy()[0]				)

							self.assertListEqual(lowerCamelCase__     ,		lowerCamelCase__				)

							self.assertEqual((2, 39)     ,		batch.input_ids.shape				)
							self.assertEqual((2, 39)     ,		batch.attention_mask.shape				)


			@require_torch
			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.canine_tokenizer
							__lowerCamelCase									=       ['Once there was a man.', 'He wrote a test in HuggingFace Tranformers.']
							__lowerCamelCase									=       tokenizer(lowerCamelCase__     ,		padding=lowerCamelCase__     ,		return_tensors='pt'				)
							# check if input_ids, attention_mask and token_type_ids are returned
							self.assertIn('input_ids'     ,		lowerCamelCase__				)
							self.assertIn('attention_mask'     ,		lowerCamelCase__				)
							self.assertIn('token_type_ids'     ,		lowerCamelCase__				)


			@require_torch
			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       self.canine_tokenizer
							__lowerCamelCase									=       [
							    'What\'s the weater?',
							    'It\'s about 25 degrees.',
							]
							__lowerCamelCase									=       tokenizer(
							    text_target=lowerCamelCase__     ,		max_length=32     ,		padding='max_length'     ,		truncation=lowerCamelCase__     ,		return_tensors='pt'				)
							self.assertEqual(32     ,		targets['input_ids'].shape[1]				)


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



							'''simple docstring'''
							# safety check on max_len default value so we are sure the test works
							__lowerCamelCase									=       self.get_tokenizers()
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															self.assertNotEqual(tokenizer.model_max_length     ,		42				)

        # Now let's start the test
							__lowerCamelCase									=       self.get_tokenizers()
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															# Isolate this from the other tests because we save additional tokens/etc
															__lowerCamelCase									=       tempfile.mkdtemp()

															__lowerCamelCase									=       ' He is very happy, UNwant\u00E9d,running'
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															tokenizer.save_pretrained(lowerCamelCase__				)

															__lowerCamelCase									=       tokenizer.__class__.from_pretrained(lowerCamelCase__				)
															__lowerCamelCase									=       after_tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															self.assertListEqual(lowerCamelCase__     ,		lowerCamelCase__				)

															shutil.rmtree(lowerCamelCase__				)

							__lowerCamelCase									=       self.get_tokenizers(model_max_length=42				)
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															# Isolate this from the other tests because we save additional tokens/etc
															__lowerCamelCase									=       tempfile.mkdtemp()

															__lowerCamelCase									=       ' He is very happy, UNwant\u00E9d,running'

															__lowerCamelCase									=       tokenizer.additional_special_tokens

															# We can add a new special token for Canine as follows:
															__lowerCamelCase									=       chr(0xe_007				)
															additional_special_tokens.append(lowerCamelCase__				)
															tokenizer.add_special_tokens({'additional_special_tokens': additional_special_tokens}				)
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															tokenizer.save_pretrained(lowerCamelCase__				)

															__lowerCamelCase									=       tokenizer.__class__.from_pretrained(lowerCamelCase__				)
															__lowerCamelCase									=       after_tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															self.assertListEqual(lowerCamelCase__     ,		lowerCamelCase__				)
															self.assertIn(lowerCamelCase__     ,		after_tokenizer.additional_special_tokens				)
															self.assertEqual(after_tokenizer.model_max_length     ,		42				)

															__lowerCamelCase									=       tokenizer.__class__.from_pretrained(lowerCamelCase__     ,		model_max_length=43				)
															self.assertEqual(tokenizer.model_max_length     ,		43				)

															shutil.rmtree(lowerCamelCase__				)


			def  lowercase_       ( self				)       -> Any:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizers(do_lower_case=lowerCamelCase__				)
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															__lowerCamelCase			,		__lowerCamelCase									=       self.get_clean_sequence(lowerCamelCase__				)

															# a special token for Canine can be defined as follows:
															__lowerCamelCase									=       0xe_005
															__lowerCamelCase									=       chr(lowerCamelCase__				)

															tokenizer.add_special_tokens({'cls_token': special_token}				)
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															self.assertEqual(len(lowerCamelCase__				)     ,		1				)

															__lowerCamelCase									=       tokenizer.decode(ids + encoded_special_token     ,		clean_up_tokenization_spaces=lowerCamelCase__				)
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)

															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															self.assertEqual(lowerCamelCase__     ,		input_encoded + special_token_id				)

															__lowerCamelCase									=       tokenizer.decode(lowerCamelCase__     ,		skip_special_tokens=lowerCamelCase__				)
															self.assertTrue(special_token not in decoded				)


			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizers(do_lower_case=lowerCamelCase__				)
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															__lowerCamelCase									=       chr(0xe_005				)
															__lowerCamelCase									=       chr(0xe_006				)

															# `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
															tokenizer.add_tokens([SPECIAL_TOKEN_1]     ,		special_tokens=lowerCamelCase__				)
															# `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
															# which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
															tokenizer.add_special_tokens({'additional_special_tokens': [SPECIAL_TOKEN_2]}				)

															__lowerCamelCase									=       tokenizer.tokenize(lowerCamelCase__				)
															__lowerCamelCase									=       tokenizer.tokenize(lowerCamelCase__				)

															self.assertEqual(len(lowerCamelCase__				)     ,		1				)
															self.assertEqual(len(lowerCamelCase__				)     ,		1				)
															self.assertEqual(token_a[0]     ,		lowerCamelCase__				)
															self.assertEqual(token_a[0]     ,		lowerCamelCase__				)


			@require_tokenizers
			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizers(do_lower_case=lowerCamelCase__				)
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															# a special token for Canine can be defined as follows:
															__lowerCamelCase									=       0xe_006
															__lowerCamelCase									=       chr(lowerCamelCase__				)

															__lowerCamelCase									=       AddedToken(lowerCamelCase__     ,		lstrip=lowerCamelCase__				)
															tokenizer.add_special_tokens({'additional_special_tokens': [new_token]}				)

															with tempfile.TemporaryDirectory() as tmp_dir_name:
																			tokenizer.save_pretrained(lowerCamelCase__				)
																			tokenizer.from_pretrained(lowerCamelCase__				)


			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       []
							if self.test_slow_tokenizer:
											tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())				)

							if self.test_rust_tokenizer:
											tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())				)

							for tokenizer_class, tokenizer_utils in tokenizer_list:
											with tempfile.TemporaryDirectory() as tmp_dir:
															tokenizer_utils.save_pretrained(lowerCamelCase__				)

															with open(os.path.join(lowerCamelCase__     ,		'special_tokens_map.json'				)     ,		encoding='utf-8'				) as json_file:
																			__lowerCamelCase									=       json.load(lowerCamelCase__				)

															with open(os.path.join(lowerCamelCase__     ,		'tokenizer_config.json'				)     ,		encoding='utf-8'				) as json_file:
																			__lowerCamelCase									=       json.load(lowerCamelCase__				)

															# a special token for Canine can be defined as follows:
															__lowerCamelCase									=       0xe_006
															__lowerCamelCase									=       chr(lowerCamelCase__				)

															__lowerCamelCase									=       [new_token_a]
															__lowerCamelCase									=       [new_token_a]

															with open(os.path.join(lowerCamelCase__     ,		'special_tokens_map.json'				)     ,		'w'     ,		encoding='utf-8'				) as outfile:
																			json.dump(lowerCamelCase__     ,		lowerCamelCase__				)
															with open(os.path.join(lowerCamelCase__     ,		'tokenizer_config.json'				)     ,		'w'     ,		encoding='utf-8'				) as outfile:
																			json.dump(lowerCamelCase__     ,		lowerCamelCase__				)

															# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
															# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
															# "special_tokens_map.json" files
															__lowerCamelCase									=       tokenizer_class.from_pretrained(lowerCamelCase__     ,		extra_ids=0				)
															self.assertIn(lowerCamelCase__     ,		tokenizer_without_change_in_init.additional_special_tokens				)
															# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
															self.assertEqual(
															    [new_token_a]     ,		tokenizer_without_change_in_init.convert_ids_to_tokens(
															        tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]				)				)     ,		)

															__lowerCamelCase									=       0xe_007
															__lowerCamelCase									=       chr(lowerCamelCase__				)
															# Now we test that we can change the value of additional_special_tokens in the from_pretrained
															__lowerCamelCase									=       [AddedToken(lowerCamelCase__     ,		lstrip=lowerCamelCase__				)]
															__lowerCamelCase									=       tokenizer_class.from_pretrained(
															    lowerCamelCase__     ,		additional_special_tokens=lowerCamelCase__     ,		extra_ids=0				)

															self.assertIn(lowerCamelCase__     ,		tokenizer.additional_special_tokens				)
															# self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
															self.assertEqual(
															    [new_token_a]     ,		tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]				)				)				)


			@require_tokenizers
			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizers(do_lower_case=lowerCamelCase__				)
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															__lowerCamelCase									=       'hello world'
															if self.space_between_special_tokens:
																			__lowerCamelCase									=       '[CLS] hello world [SEP]'
															else:
																			__lowerCamelCase									=       input
															__lowerCamelCase									=       tokenizer.encode(lowerCamelCase__     ,		add_special_tokens=lowerCamelCase__				)
															__lowerCamelCase									=       tokenizer.decode(lowerCamelCase__     ,		spaces_between_special_tokens=self.space_between_special_tokens				)
															self.assertIn(lowerCamelCase__     ,		[output, output.lower()]				)


			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizers()
							for tokenizer in tokenizers:
											with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
															__lowerCamelCase									=       [
															    'bos_token',
															    'eos_token',
															    'unk_token',
															    'sep_token',
															    'pad_token',
															    'cls_token',
															    'mask_token',
															]

							__lowerCamelCase									=       'a'
							__lowerCamelCase									=       ord(lowerCamelCase__				)

							for attr in attributes_list:
											setattr(lowerCamelCase__     ,		attr + '_id'     ,		lowerCamelCase__				)
											self.assertEqual(getattr(lowerCamelCase__     ,		lowerCamelCase__				)     ,		lowerCamelCase__				)
											self.assertEqual(getattr(lowerCamelCase__     ,		attr + '_id'				)     ,		lowerCamelCase__				)

											setattr(lowerCamelCase__     ,		attr + '_id'     ,		lowerCamelCase__				)
											self.assertEqual(getattr(lowerCamelCase__     ,		lowerCamelCase__				)     ,		lowerCamelCase__				)
											self.assertEqual(getattr(lowerCamelCase__     ,		attr + '_id'				)     ,		lowerCamelCase__				)

							setattr(lowerCamelCase__     ,		'additional_special_tokens_ids'     ,		[]				)
							self.assertListEqual(getattr(lowerCamelCase__     ,		'additional_special_tokens'				)     ,		[]				)
							self.assertListEqual(getattr(lowerCamelCase__     ,		'additional_special_tokens_ids'				)     ,		[]				)

							__lowerCamelCase									=       0xe_006
							__lowerCamelCase									=       chr(lowerCamelCase__				)
							setattr(lowerCamelCase__     ,		'additional_special_tokens_ids'     ,		[additional_special_token_id]				)
							self.assertListEqual(getattr(lowerCamelCase__     ,		'additional_special_tokens'				)     ,		[additional_special_token]				)
							self.assertListEqual(getattr(lowerCamelCase__     ,		'additional_special_tokens_ids'				)     ,		[additional_special_token_id]				)


			def  lowercase_       ( self				)       -> Any:



							'''simple docstring'''
							pass


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



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Optional[Any]:



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Tuple:



							'''simple docstring'''
							pass


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



							'''simple docstring'''
							pass






			def  lowercase_       ( self				)       -> Optional[int]:



							'''simple docstring'''
							pass








import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			['''image_processor''', '''tokenizer''']
			snake_case_  						=			'''OwlViTImageProcessor'''
			snake_case_  						=			('''CLIPTokenizer''', '''CLIPTokenizerFast''')


			def __init__( self     ,		lowerCamelCase__=None     ,		lowerCamelCase__=None     ,		**lowerCamelCase__				)       -> Tuple:



							'''simple docstring'''
							__lowerCamelCase									=       None
							if "feature_extractor" in kwargs:
											warnings.warn(
											    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
											    ' instead.'     ,		lowerCamelCase__     ,		)
											__lowerCamelCase									=       kwargs.pop('feature_extractor'				)

							__lowerCamelCase									=       image_processor if image_processor is not None else feature_extractor
							if image_processor is None:
											raise ValueError('You need to specify an `image_processor`.'				)
							if tokenizer is None:
											raise ValueError('You need to specify a `tokenizer`.'				)

							super().__init__(lowerCamelCase__     ,		lowerCamelCase__				)


			def __call__( self     ,		lowerCamelCase__=None     ,		lowerCamelCase__=None     ,		lowerCamelCase__=None     ,		lowerCamelCase__="max_length"     ,		lowerCamelCase__="np"     ,		**lowerCamelCase__				)       -> Optional[int]:



							'''simple docstring'''

							if text is None and query_images is None and images is None:
											raise ValueError(
											    'You have to specify at least one text or query image or image. All three cannot be none.'				)

							if text is not None:
											if isinstance(lowerCamelCase__     ,		lowerCamelCase__				) or (isinstance(lowerCamelCase__     ,		lowerCamelCase__				) and not isinstance(text[0]     ,		lowerCamelCase__				)):
															__lowerCamelCase									=       [self.tokenizer(lowerCamelCase__     ,		padding=lowerCamelCase__     ,		return_tensors=lowerCamelCase__     ,		**lowerCamelCase__				)]

											elif isinstance(lowerCamelCase__     ,		lowerCamelCase__				) and isinstance(text[0]     ,		lowerCamelCase__				):
															__lowerCamelCase									=       []

															# Maximum number of queries across batch
															__lowerCamelCase									=       max([len(lowerCamelCase__				) for t in text]				)

															# Pad all batch samples to max number of text queries
															for t in text:
																			if len(lowerCamelCase__				) != max_num_queries:
																							__lowerCamelCase									=       t + [' '] * (max_num_queries - len(lowerCamelCase__				))

																			__lowerCamelCase									=       self.tokenizer(lowerCamelCase__     ,		padding=lowerCamelCase__     ,		return_tensors=lowerCamelCase__     ,		**lowerCamelCase__				)
																			encodings.append(lowerCamelCase__				)
											else:
															raise TypeError('Input text should be a string, a list of strings or a nested list of strings'				)

											if return_tensors == "np":
															__lowerCamelCase									=       np.concatenate([encoding['input_ids'] for encoding in encodings]     ,		axis=0				)
															__lowerCamelCase									=       np.concatenate([encoding['attention_mask'] for encoding in encodings]     ,		axis=0				)

											elif return_tensors == "jax" and is_flax_available():
															import jax.numpy as jnp

															__lowerCamelCase									=       jnp.concatenate([encoding['input_ids'] for encoding in encodings]     ,		axis=0				)
															__lowerCamelCase									=       jnp.concatenate([encoding['attention_mask'] for encoding in encodings]     ,		axis=0				)

											elif return_tensors == "pt" and is_torch_available():
															import torch

															__lowerCamelCase									=       torch.cat([encoding['input_ids'] for encoding in encodings]     ,		dim=0				)
															__lowerCamelCase									=       torch.cat([encoding['attention_mask'] for encoding in encodings]     ,		dim=0				)

											elif return_tensors == "tf" and is_tf_available():
															import tensorflow as tf

															__lowerCamelCase									=       tf.stack([encoding['input_ids'] for encoding in encodings]     ,		axis=0				)
															__lowerCamelCase									=       tf.stack([encoding['attention_mask'] for encoding in encodings]     ,		axis=0				)

											else:
															raise ValueError('Target return tensor type could not be returned'				)

											__lowerCamelCase									=       BatchEncoding()
											__lowerCamelCase									=       input_ids
											__lowerCamelCase									=       attention_mask

							if query_images is not None:
											__lowerCamelCase									=       BatchEncoding()
											__lowerCamelCase									=       self.image_processor(
											    lowerCamelCase__     ,		return_tensors=lowerCamelCase__     ,		**lowerCamelCase__				).pixel_values
											__lowerCamelCase									=       query_pixel_values

							if images is not None:
											__lowerCamelCase									=       self.image_processor(lowerCamelCase__     ,		return_tensors=lowerCamelCase__     ,		**lowerCamelCase__				)

							if text is not None and images is not None:
											__lowerCamelCase									=       image_features.pixel_values
											return encoding
							elif query_images is not None and images is not None:
											__lowerCamelCase									=       image_features.pixel_values
											return encoding
							elif text is not None or query_images is not None:
											return encoding
							else:
											return BatchEncoding(data=dict(**lowerCamelCase__				)     ,		tensor_type=lowerCamelCase__				)


			def  lowercase_       ( self     ,		*lowerCamelCase__     ,		**lowerCamelCase__				)       -> Tuple:



							'''simple docstring'''
							return self.image_processor.post_process(*lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		*lowerCamelCase__     ,		**lowerCamelCase__				)       -> Optional[Any]:



							'''simple docstring'''
							return self.image_processor.post_process_object_detection(*lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		*lowerCamelCase__     ,		**lowerCamelCase__				)       -> Optional[int]:



							'''simple docstring'''
							return self.image_processor.post_process_image_guided_detection(*lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		*lowerCamelCase__     ,		**lowerCamelCase__				)       -> Optional[int]:



							'''simple docstring'''
							return self.tokenizer.batch_decode(*lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		*lowerCamelCase__     ,		**lowerCamelCase__				)       -> Optional[int]:



							'''simple docstring'''
							return self.tokenizer.decode(*lowerCamelCase__     ,		**lowerCamelCase__				)


			@property
			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							warnings.warn(
							    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'     ,		lowerCamelCase__     ,		)
							return self.image_processor_class






			@property
			def  lowercase_       ( self				)       -> Union[str, Any]:



							'''simple docstring'''
							warnings.warn(
							    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'     ,		lowerCamelCase__     ,		)
							return self.image_processor


