


import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
						import jax

						from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
						from transformers.models.bert.modeling_flax_bert import FlaxBertModel
						from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel
@require_flax
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				@slow
				def 		__magic_name__(       self			:str	)		->			int:
										for model_name in ["bert-base-cased", "bert-large-uncased"]:
																with self.subTest(lowerCAmelCase__	):
																						__SCREAMING_SNAKE_CASE						:     Dict					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																						self.assertIsNotNone(lowerCAmelCase__	)
																						self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     int					=		FlaxAutoModel.from_pretrained(lowerCAmelCase__	)
																						self.assertIsNotNone(lowerCAmelCase__	)
																						self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:Dict	)		->			Dict:
										for model_name in ["roberta-base", "roberta-large"]:
																with self.subTest(lowerCAmelCase__	):
																						__SCREAMING_SNAKE_CASE						:     List[Any]					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																						self.assertIsNotNone(lowerCAmelCase__	)
																						self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		FlaxAutoModel.from_pretrained(lowerCAmelCase__	)
																						self.assertIsNotNone(lowerCAmelCase__	)
																						self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:Optional[int]	)		->			List[Any]:
										for model_name in ["bert-base-cased", "bert-large-uncased"]:
																__SCREAMING_SNAKE_CASE						:     Optional[int]					=		AutoTokenizer.from_pretrained(lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE						:     Optional[int]					=		FlaxBertModel.from_pretrained(lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		tokenizer('''Do you support jax jitted function?'''			,			return_tensors=TensorType.JAX	)

																@jax.jit
																def eval(**lowerCAmelCase__			:List[Any]	):
																						return model(**lowerCAmelCase__	)

																eval(**lowerCAmelCase__	).block_until_ready()


				@slow
				def 		__magic_name__(       self			:List[str]	)		->			Optional[int]:
										for model_name in ["roberta-base", "roberta-large"]:
																__SCREAMING_SNAKE_CASE						:     str					=		AutoTokenizer.from_pretrained(lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		FlaxRobertaModel.from_pretrained(lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE						:     Optional[int]					=		tokenizer('''Do you support jax jitted function?'''			,			return_tensors=TensorType.JAX	)

																@jax.jit
																def eval(**lowerCAmelCase__			:List[Any]	):
																						return model(**lowerCAmelCase__	)

																eval(**lowerCAmelCase__	).block_until_ready()


				def 		__magic_name__(       self			:Dict	)		->			Union[str, Any]:
										with self.assertRaisesRegex(
										    lowerCAmelCase__			,			'''bert-base is not a local folder and is not a valid model identifier'''	):
																__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		FlaxAutoModel.from_pretrained('''bert-base'''	)


				def 		__magic_name__(       self			:int	)		->			Optional[int]:
										with self.assertRaisesRegex(
										    lowerCAmelCase__			,			r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''	):
																__SCREAMING_SNAKE_CASE						:     Optional[int]					=		FlaxAutoModel.from_pretrained(lowerCAmelCase__			,			revision='''aaaaaa'''	)


				def 		__magic_name__(       self			:str	)		->			Tuple:
										with self.assertRaisesRegex(
										    lowerCAmelCase__			,			'''hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack'''			,			):
																__SCREAMING_SNAKE_CASE						:     str					=		FlaxAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''	)



				def 		__magic_name__(       self			:Dict	)		->			int:
										with self.assertRaisesRegex(lowerCAmelCase__			,			'''Use `from_pt=True` to load this model'''	):
																__SCREAMING_SNAKE_CASE						:     Dict					=		FlaxAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''	)




import unittest

from transformers.testing_utils import require_bsa
from transformers.utils import is_bsa_available

from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin


if is_bsa_available():
						from transformers import MarkupLMFeatureExtractor
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				def __init__(       self			:Optional[Any]			,			lowerCAmelCase__			:Optional[Any]	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		parent



				def 		__magic_name__(       self			:List[Any]	)		->			Tuple:
										return {}




def        _UpperCamelCase							(      ):
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''<HTML>

    <HEAD>
    <TITLE>sample document</TITLE>
    </HEAD>

    <BODY BGCOLOR="FFFFFF">
    <HR>
    <a href="http://google.com">Goog</a>
    <H1>This is one header</H1>
    <H2>This is a another Header</H2>
    <P>Travel from
        <P>
        <B>SFO to JFK</B>
        <BR>
        <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>
        <HR>
        <div style="color:#0000FF">
            <h3>Traveler <b> name </b> is
            <p> John Doe </p>
        </div>'''

						__SCREAMING_SNAKE_CASE						:     str					=		'''
    <!DOCTYPE html>
    <html>
    <body>

    <h1>My First Heading</h1>
    <p>My first paragraph.</p>

    </body>
    </html>
    '''

						return [html_string_a, html_string_a]
@require_bsa
class        _lowercase      (			A__						,			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Optional[int]						=		MarkupLMFeatureExtractor if is_bsa_available() else None


				def 		__magic_name__(       self			:int	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		MarkupLMFeatureExtractionTester(self	)


				@property
				def 		__magic_name__(       self			:Any	)		->			Optional[Any]:
										return self.feature_extract_tester.prepare_feat_extract_dict()



				def 		__magic_name__(       self			:Optional[int]	)		->			Any:
										# Initialize feature_extractor
										__SCREAMING_SNAKE_CASE						:     int					=		self.feature_extraction_class()

										# Test not batched input
										__SCREAMING_SNAKE_CASE						:     Tuple					=		get_html_strings()[0]
										__SCREAMING_SNAKE_CASE						:     Dict					=		feature_extractor(lowerCAmelCase__	)

										# fmt: off
										__SCREAMING_SNAKE_CASE						:     str					=		[['''sample document''', '''Goog''', '''This is one header''', '''This is a another Header''', '''Travel from''', '''SFO to JFK''', '''on May 2, 2015 at 2:00 pm. For details go to confirm.com''', '''Traveler''', '''name''', '''is''', '''John Doe''']]
										__SCREAMING_SNAKE_CASE						:     List[str]					=		[['''/html/head/title''', '''/html/body/a''', '''/html/body/h1''', '''/html/body/h2''', '''/html/body/p''', '''/html/body/p/p/b[1]''', '''/html/body/p/p/b[2]/i''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/b''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/p''']]
										# fmt: on

										self.assertEqual(encoding.nodes			,			lowerCAmelCase__	)
										self.assertEqual(encoding.xpaths			,			lowerCAmelCase__	)

										# Test batched
										__SCREAMING_SNAKE_CASE						:     Tuple					=		get_html_strings()
										__SCREAMING_SNAKE_CASE						:     Dict					=		feature_extractor(lowerCAmelCase__	)

										# fmt: off
										__SCREAMING_SNAKE_CASE						:     int					=		expected_nodes + [['''My First Heading''', '''My first paragraph.''']]
										__SCREAMING_SNAKE_CASE						:     str					=		expected_xpaths + [['''/html/body/h1''', '''/html/body/p''']]

										self.assertEqual(len(encoding.nodes	)			,			2	)
										self.assertEqual(len(encoding.xpaths	)			,			2	)

										self.assertEqual(encoding.nodes			,			lowerCAmelCase__	)
										self.assertEqual(encoding.xpaths			,			lowerCAmelCase__	)
