"""simple docstring"""





import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__A  =				get_tests_dir('''fixtures/spiece.model''')
@require_sentencepiece
@require_tokenizers
class  _snake_case     (					a__				, unittest.TestCase		):
      snake_case__			  =			DebertaVaTokenizer
      snake_case__			  =			DebertaVaTokenizerFast
      snake_case__			  =			True
      snake_case__			  =			True






      def       lowerCamelCase__     (       self      :			Any    ):
             super().setUp()

             # We have a SentencePiece fixture for testing
             __lowerCamelCase					:		List[str]		   =     DebertaVaTokenizer(UpperCAmelCase							,					unk_token="<unk>"    )
             tokenizer.save_pretrained(self.tmpdirname    )






      def       lowerCamelCase__     (       self      :			Tuple							,					UpperCAmelCase      :			Union[str, Any]    ):
             __lowerCamelCase					:		Dict		   =     "this is a test"
             __lowerCamelCase					:		Dict		   =     "this is a test"
             return input_text, output_text






      def       lowerCamelCase__     (       self      :			List[str]    ):
             __lowerCamelCase					:		Optional[int]		   =     "<pad>"
             __lowerCamelCase					:		Union[str, Any]		   =     0

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCAmelCase    )							,					UpperCAmelCase    )
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCAmelCase    )							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Union[str, Any]    ):
             __lowerCamelCase					:		List[str]		   =     list(self.get_tokenizer().get_vocab().keys()    )
             self.assertEqual(vocab_keys[0]							,					"<pad>"    )
             self.assertEqual(vocab_keys[1]							,					"<unk>"    )
             self.assertEqual(vocab_keys[-1]							,					"[PAD]"    )
             self.assertEqual(len(UpperCAmelCase    )							,					30001    )






      def       lowerCamelCase__     (       self      :			Optional[Any]    ):
             self.assertEqual(self.get_tokenizer().vocab_size							,					30000    )






      def       lowerCamelCase__     (       self      :			str    ):
             # fmt: off
             __lowerCamelCase					:		str		   =     " \tHeLLo!how  \n Are yoU?  "
             __lowerCamelCase					:		Any		   =     ["▁hello", "!", "how", "▁are", "▁you", "?"]
             # fmt: on

             __lowerCamelCase					:		List[Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					do_lower_case=UpperCAmelCase    )
             __lowerCamelCase					:		Dict		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Tuple		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					do_lower_case=UpperCAmelCase    )
             __lowerCamelCase					:		str		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      @unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."    )
      def       lowerCamelCase__     (       self      :			int    ):
             pass






      @unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."    )
      def       lowerCamelCase__     (       self      :			int    ):
             pass






      def       lowerCamelCase__     (       self      :			List[Any]    ):
             # fmt: off
             __lowerCamelCase					:		Union[str, Any]		   =     "I was born in 92000, and this is falsé."
             __lowerCamelCase					:		Tuple		   =     ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
             # fmt: on

             __lowerCamelCase					:		Optional[Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Optional[Any]		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Dict		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Any		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[Any]    ):
             # fmt: off
             __lowerCamelCase					:		str		   =     "I was born in 92000, and this is falsé."
             __lowerCamelCase					:		int		   =     ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
             # fmt: on

             __lowerCamelCase					:		List[str]		   =     DebertaVaTokenizer(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Dict		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		List[Any]		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		int		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Any    ):
             # fmt: off
             __lowerCamelCase					:		Union[str, Any]		   =     "I was born in 92000, and this is falsé."
             __lowerCamelCase					:		str		   =     ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
             # fmt: on

             __lowerCamelCase					:		Union[str, Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Optional[int]		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Union[str, Any]		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Union[str, Any]		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[Any]    ):
             # fmt: off
             __lowerCamelCase					:		Optional[Any]		   =     "I was born in 92000, and this is falsé."
             __lowerCamelCase					:		Union[str, Any]		   =     ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
             # fmt: on

             __lowerCamelCase					:		List[Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Any		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Optional[Any]		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Optional[int]		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Optional[int]    ):
             # fmt: off
             __lowerCamelCase					:		int		   =     " \tHeLLo!how  \n Are yoU?  "
             __lowerCamelCase					:		Optional[int]		   =     ["▁", "<unk>", "e", "<unk>", "o", "!", "how", "▁", "<unk>", "re", "▁yo", "<unk>", "?"]
             # fmt: on

             __lowerCamelCase					:		Optional[Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		int		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		List[str]		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					do_lower_case=UpperCAmelCase							,					split_by_punct=UpperCAmelCase    )
             __lowerCamelCase					:		Tuple		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )

             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[str]    ):
             __lowerCamelCase					:		List[str]		   =     self.get_tokenizer()
             __lowerCamelCase					:		int		   =     self.get_rust_tokenizer()

             __lowerCamelCase					:		Optional[Any]		   =     "I was born in 92000, and this is falsé."

             __lowerCamelCase					:		Any		   =     tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )
             __lowerCamelCase					:		Optional[int]		   =     rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Dict		   =     tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             __lowerCamelCase					:		int		   =     rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Dict		   =     self.get_rust_tokenizer()
             __lowerCamelCase					:		Optional[Any]		   =     tokenizer.encode(UpperCAmelCase    )
             __lowerCamelCase					:		Union[str, Any]		   =     rust_tokenizer.encode(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Optional[int]    ):
             __lowerCamelCase					:		Union[str, Any]		   =     "This is a test"
             __lowerCamelCase					:		Optional[int]		   =     [13, 1, 4398, 25, 21, 1289]
             __lowerCamelCase					:		Union[str, Any]		   =     ["▁", "T", "his", "▁is", "▁a", "▁test"]
             __lowerCamelCase					:		List[Any]		   =     ["▁", "<unk>", "his", "▁is", "▁a", "▁test"]

             __lowerCamelCase					:		Optional[Any]		   =     DebertaVaTokenizer(UpperCAmelCase							,					keep_accents=UpperCAmelCase    )
             __lowerCamelCase					:		List[str]		   =     DebertaVaTokenizerFast(UpperCAmelCase							,					keep_accents=UpperCAmelCase    )

             __lowerCamelCase					:		Optional[int]		   =     tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		List[Any]		   =     tokenizer.tokenize(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		Optional[Any]		   =     tokenizer.convert_ids_to_tokens(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		int		   =     rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		Tuple		   =     rust_tokenizer.tokenize(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		Tuple		   =     rust_tokenizer.convert_ids_to_tokens(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             # fmt: off
             __lowerCamelCase					:		str		   =     "I was born in 92000, and this is falsé."
             __lowerCamelCase					:		Optional[Any]		   =     [13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
             __lowerCamelCase					:		Optional[int]		   =     ["▁", "I", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "é", ".", ]
             __lowerCamelCase					:		List[Any]		   =     ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
             # fmt: on

             __lowerCamelCase					:		str		   =     tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		List[str]		   =     tokenizer.tokenize(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		Optional[int]		   =     tokenizer.convert_ids_to_tokens(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

             __lowerCamelCase					:		Optional[int]		   =     rust_tokenizer.encode(UpperCAmelCase							,					add_special_tokens=UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		Optional[Any]		   =     rust_tokenizer.tokenize(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )
             __lowerCamelCase					:		str		   =     rust_tokenizer.convert_ids_to_tokens(UpperCAmelCase    )
             self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[str]    ):
             __lowerCamelCase					:		Dict		   =     DebertaVaTokenizer(UpperCAmelCase    )

             __lowerCamelCase					:		int		   =     tokenizer.encode("sequence builders"    )
             __lowerCamelCase					:		str		   =     tokenizer.encode("multi-sequence build"    )

             __lowerCamelCase					:		Tuple		   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase    )
             __lowerCamelCase					:		int		   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase							,					UpperCAmelCase    )

             self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]							,					UpperCAmelCase    )
             self.assertEqual(
                 [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]							,					UpperCAmelCase							,					)







      @slow
      def       lowerCamelCase__     (       self      :			Optional[Any]    ):
             # fmt: off
             __lowerCamelCase					:		Tuple		   =     {"input_ids": [[1, 39867, 36, 19390, 486, 27, 35052, 81436, 18, 60685, 1225, 7, 35052, 81436, 18, 9367, 16899, 18, 15937, 53, 594, 773, 18, 16287, 30465, 36, 15937, 6, 41139, 38, 36979, 60763, 191, 6, 34132, 99, 6, 50538, 390, 43230, 6, 34132, 2779, 20850, 14, 699, 1072, 1194, 36, 382, 10901, 53, 7, 699, 1072, 2084, 36, 20422, 630, 53, 19, 105, 3049, 1896, 1053, 16899, 1506, 11, 37978, 4243, 7, 1237, 31869, 200, 16566, 654, 6, 35052, 81436, 7, 55630, 13593, 4, 2], [1, 26, 15011, 13, 667, 8, 1053, 18, 23611, 1237, 72356, 12820, 34, 104134, 1209, 35, 13313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1232, 2864, 15785, 14951, 105, 5, 8581, 1250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=UpperCAmelCase							,					model_name="microsoft/deberta-v2-xlarge"							,					revision="ad6e42c1532ddf3a15c39246b63f5559d558b670"							,					)
"""simple docstring"""





# 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  =				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    lowercase_   (   _lowerCamelCase:	List[Any]      ) ->      Union[str, 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    lowercase_   (   _lowerCamelCase:	Union[str, Any]      ) ->      Any:



							'''simple docstring'''

							from transformers.testing_utils import pytest_addoption_shared

							pytest_addoption_shared(_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Optional[int]      ) ->      Tuple:



							'''simple docstring'''

							from transformers.testing_utils import pytest_terminal_summary_main

							__lowerCamelCase					:		Any		   =     terminalreporter.config.getoption("--make-reports"      )
							if make_reports:
														pytest_terminal_summary_main(_lowerCamelCase						,   id=_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	Tuple      ) ->      Dict:



							'''simple docstring'''

							if exitstatus == 5:
														__lowerCamelCase					:		Optional[int]		   =     0


# Doctest custom flag to ignore output.
__A  =				doctest.register_optionflag('''IGNORE_RESULT''')

__A  =				doctest.OutputChecker
class  _snake_case     (					a__		):






						def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any							,					UpperCAmelCase      :			int    ):
													if IGNORE_RESULT & optionflags:
																				return True
													return OutputChecker.check_output(self							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

__A  =				CustomOutputChecker
__A  =				HfDoctestModule







__A  =				HfDocTestParser