





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


snake_case_				=			get_tests_dir('fixtures')

class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   mock.Mock()
         __snake_case							       =   500
         __snake_case							       =   {}
         __snake_case							       =   HTTPError
         __snake_case							       =   {}

         # Download this model to make sure it's in the cache.
         __snake_case							       =   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=a__      ) as mock_head:
            __snake_case							       =   WavaVecaFeatureExtractor.from_pretrained('''hf-internal-testing/tiny-random-wav2vec2'''      )
            # This check we did call the fake head request
            mock_head.assert_called()


      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   WavaVecaFeatureExtractor.from_pretrained(
             '''https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'''      )






@is_staging_test
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      @classmethod
      def    a (cls       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   TOKEN
         HfFolder.save_token(a__      )


      @classmethod
      def    a (cls       :      Optional[int]      ):





         """simple docstring"""



         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    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   WavaVecaFeatureExtractor.from_pretrained(a__      )
         feature_extractor.push_to_hub('''test-feature-extractor'''				,			use_auth_token=self._token      )

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

         # 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(
                a__				,			repo_id='''test-feature-extractor'''				,			push_to_hub=a__				,			use_auth_token=self._token      )

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


      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   WavaVecaFeatureExtractor.from_pretrained(a__      )
         feature_extractor.push_to_hub('''valid_org/test-feature-extractor'''				,			use_auth_token=self._token      )

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

         # 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(
                a__				,			repo_id='''valid_org/test-feature-extractor-org'''				,			push_to_hub=a__				,			use_auth_token=self._token      )

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


      def    a (self       :      Any      ):





         """simple docstring"""



         CustomFeatureExtractor.register_for_auto_class()
         __snake_case							       =   CustomFeatureExtractor.from_pretrained(a__      )

         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'''}				,			)

         __snake_case							       =   AutoFeatureExtractor.from_pretrained(
             f"""{USER}/test-dynamic-feature-extractor"""				,			trust_remote_code=a__      )
         # 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 lowerCamelCase__    (							snake_case_	:  list[int]       ,      snake_case_	:  int       )      ->				list[list[int]]:
   __snake_case							       =   []
   __snake_case							       =   []
   __snake_case							       =   0
   __snake_case							       =   sum(snake_case_       )
   create_state_space_tree(snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       )
   return result






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







print(*result)

