





'''simple docstring'''

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


__lowerCamelCase : Union[str, Any]											=			get_tests_dir("fixtures")

class       UpperCAmelCase (						unittest.TestCase  ):




		def 				UpperCAmelCase__   (self      :	int				)					-> List[Any]:
						# A mock response for an HTTP head request to emulate server down
						lowercase         = mock.Mock()
						lowercase         = 5_0_0
						lowercase         = {}
						lowercase         = HTTPError
						lowercase         = {}

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





		def 				UpperCAmelCase__   (self      :	str				)					-> Dict:
						# This test is for deprecated behavior and can be removed in v5
						lowercase         = WavaVecaFeatureExtractor.from_pretrained(
						    "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"				)




@is_staging_test
class       UpperCAmelCase (						unittest.TestCase  ):




		@classmethod
		def 				UpperCAmelCase__   (cls      :	List[Any]				)					-> Optional[int]:
						lowercase         = TOKEN
						HfFolder.save_token(A__				)




		@classmethod
		def 				UpperCAmelCase__   (cls      :	Optional[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 				UpperCAmelCase__   (self      :	Optional[Any]				)					-> int:
						lowercase         = WavaVecaFeatureExtractor.from_pretrained(A__				)
						feature_extractor.push_to_hub("test-feature-extractor"							,			use_auth_token=self._token				)

						lowercase         = 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				)

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




		def 				UpperCAmelCase__   (self      :	List[str]				)					-> Optional[int]:
						lowercase         = WavaVecaFeatureExtractor.from_pretrained(A__				)
						feature_extractor.push_to_hub("valid_org/test-feature-extractor"							,			use_auth_token=self._token				)

						lowercase         = 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				)

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





		def 				UpperCAmelCase__   (self      :	List[str]				)					-> Optional[int]:
						CustomFeatureExtractor.register_for_auto_class()
						lowercase         = 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"}							,			)

						lowercase         = 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"				)











'''simple docstring'''

__lowerCamelCase : str											=			8.314_4598







def 							UpperCAmelCase_    (	lowerCAmelCase_		,							lowerCAmelCase_							):

				"""simple docstring"""






				if temperature < 0:
								raise Exception("Temperature cannot be less than 0 K"							)
				if molar_mass <= 0:
								raise Exception("Molar mass cannot be less than or equal to 0 kg/mol"							)
				else:
								return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5


if __name__ == "__main__":
			import doctest

			# run doctest
			doctest.testmod()

			# example
			__lowerCamelCase : Optional[Any]											=			300
			__lowerCamelCase : Tuple											=			28
			__lowerCamelCase : str											=			rms_speed_of_molecule(temperature, molar_mass)
			print(f"Vrms of Nitrogen gas at 300 K is {vrms} m/s")




