
"""simple docstring"""



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        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				def __init__(					self	:			Optional[int]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			parent







				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Tuple:







											"""simple docstring"""




											return {}






def 	__snake_case  (    ):






							"""simple docstring"""



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

							_lowerCAmelCase  	=			'\n    <!DOCTYPE html>\n    <html>\n    <body>\n\n    <h1>My First Heading</h1>\n    <p>My first paragraph.</p>\n\n    </body>\n    </html>\n    '

							return [html_string_a, html_string_a]

@require_bsa
class        _SCREAMING_SNAKE_CASE  (  __a      ,				unittest.TestCase							):






				'''simple docstring'''



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


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MarkupLMFeatureExtractionTester(self  )


				@property
				def 				__lowerCamelCase	(					self	:			Dict  )		->  Dict:







											"""simple docstring"""




											return self.feature_extract_tester.prepare_feat_extract_dict()







				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.feature_extraction_class()

											# Test not batched input
											_lowerCAmelCase  	=			get_html_strings()[0]
											_lowerCAmelCase  	=			feature_extractor(lowerCAmelCase_  )

											# fmt: off
											_lowerCAmelCase  	=			[['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']]
											_lowerCAmelCase  	=			[['/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
											_lowerCAmelCase  	=			get_html_strings()
											_lowerCAmelCase  	=			feature_extractor(lowerCAmelCase_  )

											# fmt: off
											_lowerCAmelCase  	=			expected_nodes + [['My First Heading', 'My first paragraph.']]
											_lowerCAmelCase  	=			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_  )








"""simple docstring"""



def 	__snake_case  (    SCREAMING_SNAKE_CASE:					list[int]						):






							"""simple docstring"""



							_lowerCAmelCase  	=			[]
							if len(SCREAMING_SNAKE_CASE						) == 1:
														return [nums.copy()]
							for _ in range(len(SCREAMING_SNAKE_CASE						)						):
														_lowerCAmelCase  	=			nums.pop(0						)
														_lowerCAmelCase  	=			permute(SCREAMING_SNAKE_CASE						)
														for perm in permutations:
																					perm.append(SCREAMING_SNAKE_CASE						)
														result.extend(SCREAMING_SNAKE_CASE						)
														nums.append(SCREAMING_SNAKE_CASE						)
							return result






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					Any						):






							"""simple docstring"""



							def backtrack(SCREAMING_SNAKE_CASE:					Tuple						):
														if start == len(SCREAMING_SNAKE_CASE						) - 1:
																					output.append(nums[:]						)
														else:
																					for i in range(SCREAMING_SNAKE_CASE     ,  len(SCREAMING_SNAKE_CASE						)						):
																												_lowerCAmelCase	,		_lowerCAmelCase  	=			nums[i], nums[start]
																												backtrack(start + 1						)
																												_lowerCAmelCase	,		_lowerCAmelCase  	=			nums[i], nums[start]  # backtrack

							_lowerCAmelCase  	=			[]
							backtrack(0						)
							return output


if __name__ == "__main__":
	import doctest

	# use res to print the data in permute2 function
	_snake_case          =						permutea([1, 2, 3])
	print(res)
	doctest.testmod()






