
# 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.
A		: Union[str, 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 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	Dict       )  ->     str:
						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 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	List[Any]       )  ->     Tuple:
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(SCREAMING_SNAKE_CASE_       )




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	Optional[Any]       )  ->     str:
						from transformers.testing_utils import pytest_terminal_summary_main

						_lowercase					       =					terminalreporter.config.getoption("""--make-reports"""       )
						if make_reports:
												pytest_terminal_summary_main(SCREAMING_SNAKE_CASE_		,   id=SCREAMING_SNAKE_CASE_       )




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	List[Any]		,   SCREAMING_SNAKE_CASE_	:	Tuple       )  ->     List[str]:
						# If no tests are collected, pytest exists with code 5, which makes the CI fail.
						if exitstatus == 5:
												_lowercase					       =					0


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

A		: Dict								=     doctest.OutputChecker



class    a_ (			_a    ):






			def    UpperCamelCase_				(      self				,			__UpperCamelCase				,			__UpperCamelCase				,			__UpperCamelCase  ):
									if IGNORE_RESULT & optionflags:
															return True
									return OutputChecker.check_output(self				,			__UpperCamelCase				,			__UpperCamelCase				,			__UpperCamelCase  )







A		: Any								=     CustomOutputChecker
A		: Optional[int]								=     HfDoctestModule



A		: Any								=     HfDocTestParser

import warnings

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



class    a_ (			_a    ):
			a	:			Optional[Any]					   =							['''image_processor''', '''tokenizer''']
			a	:			Optional[Any]					   =							'''ChineseCLIPImageProcessor'''
			a	:			List[str]					   =							('''BertTokenizer''', '''BertTokenizerFast''')






			def __init__(      self				,			__UpperCamelCase=None				,			__UpperCamelCase=None				,			**__UpperCamelCase  ):
									_lowercase					       =					None
									if "feature_extractor" in kwargs:
															warnings.warn(
															    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
															    """ instead."""				,			__UpperCamelCase				,			)
															_lowercase					       =					kwargs.pop("""feature_extractor"""  )

									_lowercase					       =					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__(__UpperCamelCase				,			__UpperCamelCase  )
									_lowercase					       =					self.image_processor






			def __call__(      self				,			__UpperCamelCase=None				,			__UpperCamelCase=None				,			__UpperCamelCase=None				,			**__UpperCamelCase  ):

									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:
															_lowercase					       =					self.tokenizer(__UpperCamelCase				,			return_tensors=__UpperCamelCase				,			**__UpperCamelCase  )

									if images is not None:
															_lowercase					       =					self.image_processor(__UpperCamelCase				,			return_tensors=__UpperCamelCase				,			**__UpperCamelCase  )

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






			def    UpperCamelCase_				(      self				,			*__UpperCamelCase				,			**__UpperCamelCase  ):
									return self.tokenizer.batch_decode(*__UpperCamelCase				,			**__UpperCamelCase  )






			def    UpperCamelCase_				(      self				,			*__UpperCamelCase				,			**__UpperCamelCase  ):
									return self.tokenizer.decode(*__UpperCamelCase				,			**__UpperCamelCase  )






			@property
			def    UpperCamelCase_				(      self  ):
									_lowercase					       =					self.tokenizer.model_input_names
									_lowercase					       =					self.image_processor.model_input_names
									return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names  )  )






			@property
			def    UpperCamelCase_				(      self  ):
									warnings.warn(
									    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""				,			__UpperCamelCase				,			)
									return self.image_processor_class