



# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__snake_case     :Optional[Any]			       =abspath(join(dirname(__file__), 'src'))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Union[str, Any]				)       ->							Any:

							'''simple docstring'''






							config.addinivalue_line(
							    'markers'			,	'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'				)
							config.addinivalue_line(
							    'markers'			,	'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'				)
							config.addinivalue_line('markers'			,	'is_pipeline_test: mark test to run only when pipelines are tested'				)
							config.addinivalue_line('markers'			,	'is_staging_test: mark test to run only in the staging environment'				)
							config.addinivalue_line('markers'			,	'accelerate_tests: mark test that require accelerate'				)
							config.addinivalue_line('markers'			,	'tool_tests: mark the tool tests that are run on their specific schedule'				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	List[str]				)       ->							Any:

							'''simple docstring'''






							from transformers.testing_utils import pytest_addoption_shared

							pytest_addoption_shared(lowerCAmelCase__				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Union[str, Any]				)       ->							Union[str, Any]:

							'''simple docstring'''






							from transformers.testing_utils import pytest_terminal_summary_main

							A      						=    terminalreporter.config.getoption('--make-reports'				)
							if make_reports:
														pytest_terminal_summary_main(lowerCAmelCase__			,	id=lowerCAmelCase__				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	List[Any]			,	lowerCAmelCase__	:	Union[str, Any]				)       ->							List[Any]:

							'''simple docstring'''






							if exitstatus == 5:
														A      						=    0


# Doctest custom flag to ignore output.
__snake_case     :int			       =doctest.register_optionflag('IGNORE_RESULT')

__snake_case     :List[str]			       =doctest.OutputChecker



class        lowerCAmelCase__					(  _lowerCamelCase       ):


				def __UpperCamelCase						(							self      :  Tuple						, __UpperCamelCase      :  List[str]						, __UpperCamelCase      :  Optional[int]						, __UpperCamelCase      :  str       )		->     List[Any]:
											if IGNORE_RESULT & optionflags:
																		return True
											return OutputChecker.check_output(self						, __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase       )





__snake_case     :str			       =CustomOutputChecker
__snake_case     :List[Any]			       =HfDoctestModule



__snake_case     :str			       =HfDocTestParser

"""simple docstring"""






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding



class 			lowercase					( lowercase__		):
			lowercase        =     ['''image_processor''', '''tokenizer''']
			lowercase        =     '''CLIPImageProcessor'''
			lowercase        =     ('''XLMRobertaTokenizer''', '''XLMRobertaTokenizerFast''')






			def __init__(self  :	Union[str, Any]      ,SCREAMING_SNAKE_CASE_  :	int=None      ,SCREAMING_SNAKE_CASE_  :	str=None      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]			)       ->	int:





				"""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.'''      ,SCREAMING_SNAKE_CASE_      ,)
					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__(SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_			)






			def __call__(self  :	Union[str, Any]      ,SCREAMING_SNAKE_CASE_  :	List[str]=None      ,SCREAMING_SNAKE_CASE_  :	Optional[int]=None      ,SCREAMING_SNAKE_CASE_  :	Union[str, Any]=None      ,**SCREAMING_SNAKE_CASE_  :	Any			)       ->	List[Any]:





				"""simple docstring"""


				if text is None and images is None:
					raise ValueError('''You have to specify either text or images. Both cannot be none.'''			)

				if text is not None:
					lowerCAmelCase												=  self.tokenizer(SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)

				if images is not None:
					lowerCAmelCase												=  self.image_processor(SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)

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






			def 					UpperCAmelCase							(self  :	List[str]      ,*SCREAMING_SNAKE_CASE_  :	Union[str, Any]      ,**SCREAMING_SNAKE_CASE_  :	Tuple			)       ->	Optional[Any]:





				"""simple docstring"""


				return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	Union[str, Any]      ,*SCREAMING_SNAKE_CASE_  :	int      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]			)       ->	Any:





				"""simple docstring"""


				return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)






			@property
			def 					UpperCAmelCase							(self  :	List[Any]			)       ->	Dict:





				"""simple docstring"""


				lowerCAmelCase												=  self.tokenizer.model_input_names
				lowerCAmelCase												=  self.image_processor.model_input_names
				return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names			)			)


