






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

  def    a					(    self						:	Union[str, Any]			):
     """simple docstring"""

     __UpperCamelCase	:			Union[str, Any]					=					mock.Mock()
     __UpperCamelCase	:			int					=					5_00
     __UpperCamelCase	:			Any					=					{}
     __UpperCamelCase	:			str					=					HTTPError
     __UpperCamelCase	:			Optional[int]					=					{}

     # Download this model to make sure it's in the cache.
     __UpperCamelCase	:			List[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=lowerCamelCase__			) as mock_head:
        __UpperCamelCase	:			int					=					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"""

     __UpperCamelCase	:			List[str]					=					WavaVecaFeatureExtractor.from_pretrained(
         """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"""			)







@is_staging_test
class 		_A						( unittest.TestCase ):

  @classmethod
  def    a					(    cls						:	Dict			):
     """simple docstring"""

     __UpperCamelCase	:			Dict					=					TOKEN
     HfFolder.save_token(lowerCamelCase__			)

  @classmethod
  def    a					(    cls						:	str			):
     """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						:	Dict			):
     """simple docstring"""

     __UpperCamelCase	:			int					=					WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase__			)
     feature_extractor.push_to_hub("""test-feature-extractor"""   ,				use_auth_token=self._token			)

     __UpperCamelCase	:			Dict					=					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	:			Optional[Any]					=					WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor'			)
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase__   ,				getattr(lowerCamelCase__   ,				lowerCamelCase__			)			)

  def    a					(    self						:	int			):
     """simple docstring"""

     __UpperCamelCase	:			Any					=					WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase__			)
     feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""   ,				use_auth_token=self._token			)

     __UpperCamelCase	:			Dict					=					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	:			Tuple					=					WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org"""			)
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase__   ,				getattr(lowerCamelCase__   ,				lowerCamelCase__			)			)

  def    a					(    self						:	int			):
     """simple docstring"""

     CustomFeatureExtractor.register_for_auto_class()
     __UpperCamelCase	:			str					=					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	:			List[Any]					=					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"""			)











UpperCamelCase    							=      8.3_144_598


def 				__lowerCamelCase     (							__lowerCAmelCase							:					float					,							__lowerCAmelCase							:					float							)     ->  float:
   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
       UpperCamelCase    							=      300
       UpperCamelCase    							=      28
       UpperCamelCase    							=      rms_speed_of_molecule(temperature, molar_mass)
       print(F"""Vrms of Nitrogen gas at 300 K is {vrms} m/s""")



