



import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / '''utils'''))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


__A       =						get_tests_dir('''fixtures''')






class 		lowercase						(			unittest.TestCase):






	"""simple docstring"""


	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			List[Any]:
							UpperCAmelCase_=       mock.Mock()
							UpperCAmelCase_=       500
							UpperCAmelCase_=       {}
							UpperCAmelCase_=       HTTPError
							UpperCAmelCase_=       {}

							# Download this model to make sure it's in the cache.
							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2"""					)
							# Under the mock environment we get a 500 error when trying to reach the model.
							with mock.patch("""requests.Session.request"""						,  return_value=lowerCamelCase_					) as mock_head:
													UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2"""					)
													# This check we did call the fake head request
													mock_head.assert_called()




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			Optional[Any]:
							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained(
							    """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"""					)






@is_staging_test
class 		lowercase						(			unittest.TestCase):






	"""simple docstring"""


	@classmethod
	def   _SCREAMING_SNAKE_CASE		(     cls     :						Dict					)      ->			str:
							UpperCAmelCase_=       TOKEN
							HfFolder.save_token(lowerCamelCase_					)




	@classmethod
	def   _SCREAMING_SNAKE_CASE		(     cls     :						int					)      ->			List[str]:

							try:
													delete_repo(token=cls._token						,  repo_id="""test-feature-extractor"""					)
							except HTTPError:
													pass

							try:
													delete_repo(token=cls._token						,  repo_id="""valid_org/test-feature-extractor-org"""					)
							except HTTPError:
													pass

							try:
													delete_repo(token=cls._token						,  repo_id="""test-dynamic-feature-extractor"""					)
							except HTTPError:
													pass




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			Union[str, Any]:
							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase_					)
							feature_extractor.push_to_hub("""test-feature-extractor"""						,  use_auth_token=self._token					)

							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained(F"""{USER}/test-feature-extractor"""					)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCamelCase_						,  getattr(lowerCamelCase_						,  lowerCamelCase_					)					)

							# Reset repo
							delete_repo(token=self._token						,  repo_id="""test-feature-extractor"""					)

							# Push to hub via save_pretrained
							with tempfile.TemporaryDirectory() as tmp_dir:
													feature_extractor.save_pretrained(
													    lowerCamelCase_						,  repo_id="""test-feature-extractor"""						,  push_to_hub=lowerCamelCase_						,  use_auth_token=self._token					)

							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained(F"""{USER}/test-feature-extractor"""					)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCamelCase_						,  getattr(lowerCamelCase_						,  lowerCamelCase_					)					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			str:
							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase_					)
							feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""						,  use_auth_token=self._token					)

							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor"""					)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCamelCase_						,  getattr(lowerCamelCase_						,  lowerCamelCase_					)					)

							# Reset repo
							delete_repo(token=self._token						,  repo_id="""valid_org/test-feature-extractor"""					)

							# Push to hub via save_pretrained
							with tempfile.TemporaryDirectory() as tmp_dir:
													feature_extractor.save_pretrained(
													    lowerCamelCase_						,  repo_id="""valid_org/test-feature-extractor-org"""						,  push_to_hub=lowerCamelCase_						,  use_auth_token=self._token					)

							UpperCAmelCase_=       WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org"""					)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCamelCase_						,  getattr(lowerCamelCase_						,  lowerCamelCase_					)					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			List[Any]:
							CustomFeatureExtractor.register_for_auto_class()
							UpperCAmelCase_=       CustomFeatureExtractor.from_pretrained(lowerCamelCase_					)

							feature_extractor.push_to_hub("""test-dynamic-feature-extractor"""						,  use_auth_token=self._token					)

							# This has added the proper auto_map field to the config
							self.assertDictEqual(
							    feature_extractor.auto_map						,  {"""AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor"""}						,  )

							UpperCAmelCase_=       AutoFeatureExtractor.from_pretrained(
							    F"""{USER}/test-dynamic-feature-extractor"""						,  trust_remote_code=lowerCamelCase_					)
							# Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
							self.assertEqual(new_feature_extractor.__class__.__name__						,  """CustomFeatureExtractor"""					)




from __future__ import annotations



def 	__a					(   lowerCAmelCase_       : list[int]      ,lowerCAmelCase_       : int    )				->			list[list[int]]:






						'''simple docstring'''



						UpperCAmelCase_=       []
						UpperCAmelCase_=       []
						UpperCAmelCase_=       0
						UpperCAmelCase_=       sum(lowerCAmelCase_    )
						create_state_space_tree(lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_    )
						return result



def 	__a					(   lowerCAmelCase_       : list[int]      ,lowerCAmelCase_       : int      ,lowerCAmelCase_       : int      ,lowerCAmelCase_       : list[int]      ,lowerCAmelCase_       : list[list[int]]      ,lowerCAmelCase_       : int      ,)				->			None:






						'''simple docstring'''



						if sum(lowerCAmelCase_    ) > max_sum or (remaining_nums_sum + sum(lowerCAmelCase_    )) < max_sum:
												return
						if sum(lowerCAmelCase_    ) == max_sum:
												result.append(lowerCAmelCase_    )
												return
						for index in range(lowerCAmelCase_      ,len(lowerCAmelCase_    )    ):
												create_state_space_tree(
												    lowerCAmelCase_      ,lowerCAmelCase_      ,index + 1      ,[*path, nums[index]]      ,lowerCAmelCase_      ,remaining_nums_sum - nums[index]      ,)
__A       =						[3, 34, 4, 12, 5, 2]
__A       =						9
__A       =						generate_sum_of_subsets_soln(nums, max_sum)



print(*result)




