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


_UpperCAmelCase						=		get_tests_dir("""fixtures""")





class UpperCAmelCase						(					unittest.TestCase  ):


				'''simple docstring'''






				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				Optional[Any]     =      mock.Mock()
						A_		:				Union[str, Any]     =      5_0_0
						A_		:				str     =      {}
						A_		:				Any     =      HTTPError
						A_		:				List[Any]     =      {}

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







				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





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





@is_staging_test
class UpperCAmelCase						(					unittest.TestCase  ):


				'''simple docstring'''






				@classmethod
				def   lowerCAmelCase_   (						cls					):



						"""simple docstring"""





						A_		:				Any     =      TOKEN
						HfFolder.save_token(UpperCamelCase__					)
				@classmethod
				def   lowerCAmelCase_   (						cls					):



						"""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   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				Any     =      WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__					)
						feature_extractor.push_to_hub('test-feature-extractor'		,	use_auth_token=self._token					)

						A_		:				Optional[Any]     =      WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''					)
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(UpperCamelCase__		,	getattr(UpperCamelCase__		,	UpperCamelCase__					)					)

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

						A_		:				Union[str, Any]     =      WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''					)
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(UpperCamelCase__		,	getattr(UpperCamelCase__		,	UpperCamelCase__					)					)
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				str     =      WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__					)
						feature_extractor.push_to_hub('valid_org/test-feature-extractor'		,	use_auth_token=self._token					)

						A_		:				Optional[Any]     =      WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor'					)
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(UpperCamelCase__		,	getattr(UpperCamelCase__		,	UpperCamelCase__					)					)

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

						A_		:				Optional[Any]     =      WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor-org'					)
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(UpperCamelCase__		,	getattr(UpperCamelCase__		,	UpperCamelCase__					)					)







				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						CustomFeatureExtractor.register_for_auto_class()
						A_		:				List[str]     =      CustomFeatureExtractor.from_pretrained(UpperCamelCase__					)

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

						A_		:				Union[str, Any]     =      AutoFeatureExtractor.from_pretrained(
						    F'''{USER}/test-dynamic-feature-extractor'''		,	trust_remote_code=UpperCamelCase__					)
						# 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

import requests

def      A      (      _SCREAMING_SNAKE_CASE    )	-> dict:
       lowerCamelCase   :      Tuple			 =					f'''https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty'''
       return requests.get(_SCREAMING_SNAKE_CASE    ).json()

def      A      (      _SCREAMING_SNAKE_CASE = 10    )	-> list[dict]:
       lowerCamelCase   :      str			 =					"https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty"
       lowerCamelCase   :      Any			 =					requests.get(_SCREAMING_SNAKE_CASE    ).json()[:max_stories]
       return [get_hackernews_story(_SCREAMING_SNAKE_CASE    ) for story_id in story_ids]

def      A      (      _SCREAMING_SNAKE_CASE = 10    )	-> str:
       lowerCamelCase   :      str			 =					hackernews_top_stories(_SCREAMING_SNAKE_CASE    )
       return "\n".join("* [{title}]({url})".format(**_SCREAMING_SNAKE_CASE    ) for story in stories    )


if __name__ == "__main__":
       print(hackernews_top_stories_as_markdown())






