

# 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.
lowerCAmelCase							:  List[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 			A_      (    _UpperCAmelCase    ):
						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 			A_      (    _UpperCAmelCase    ):
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(_UpperCAmelCase    )







def 			A_      (    _UpperCAmelCase    ):
						from transformers.testing_utils import pytest_terminal_summary_main

						SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       terminalreporter.config.getoption("--make-reports"    )
						if make_reports:
												pytest_terminal_summary_main(_UpperCAmelCase				,	id=_UpperCAmelCase    )







def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase    ):
						# If no tests are collected, pytest exists with code 5, which makes the CI fail.
						if exitstatus == 5:
												SCREAMING_SNAKE_CASE_: Tuple  		=       0


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

lowerCAmelCase							:  str   	=						doctest.OutputChecker



class   __lowercase				( UpperCAmelCase_	):




			"""simple docstring"""







			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[Any]   ,						lowerCAmelCase__  :     Optional[int]   ,						lowerCAmelCase__  :     Union[str, Any]   ,						lowerCAmelCase__  :     int):
									if IGNORE_RESULT & optionflags:
															return True
									return OutputChecker.check_output(self   ,						lowerCAmelCase__   ,						lowerCAmelCase__   ,						lowerCAmelCase__)







lowerCAmelCase							:  Union[str, Any]   	=						CustomOutputChecker
lowerCAmelCase							:  Dict   	=						HfDoctestModule



lowerCAmelCase							:  Union[str, Any]   	=						HfDocTestParser









def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase = False    ):

						if not isinstance(_UpperCAmelCase				,	_UpperCAmelCase    ):
												SCREAMING_SNAKE_CASE_: str  		=       f"Expected string as input, found {type(_UpperCAmelCase    )}"
												raise ValueError(_UpperCAmelCase    )
						if not isinstance(_UpperCAmelCase				,	_UpperCAmelCase    ):
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       f"Expected boolean as use_pascal parameter, found {type(_UpperCAmelCase    )}"
												raise ValueError(_UpperCAmelCase    )

						SCREAMING_SNAKE_CASE_: Tuple  		=       input_str.split("_"    )

						SCREAMING_SNAKE_CASE_: str  		=       0 if use_pascal else 1

						SCREAMING_SNAKE_CASE_: int  		=       words[start_index:]

						SCREAMING_SNAKE_CASE_: List[str]  		=       [word[0].upper() + word[1:] for word in words_to_capitalize]

						SCREAMING_SNAKE_CASE_: List[Any]  		=       "" if use_pascal else words[0]

						return "".join([initial_word, *capitalized_words]    )


if __name__ == "__main__":
						from doctest import testmod

						testmod()






