

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     :   str						     =  get_tests_dir('fixtures')
class  _A		(  unittest.TestCase):

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  int           =     mock.Mock()
        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     500
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     {}
        SCREAMING_SNAKE_CASE_				:  Tuple           =     HTTPError
        SCREAMING_SNAKE_CASE_				:  Any           =     {}

        # Download this model to make sure it's in the cache.
        SCREAMING_SNAKE_CASE_				:  Tuple           =     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:
              SCREAMING_SNAKE_CASE_				:  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  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     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  UpperCAmelCase    (				cls					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     TOKEN
        HfFolder.save_token(a_					)

  @classmethod
  def  UpperCAmelCase    (				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  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Dict           =     WavaVecaFeatureExtractor.from_pretrained(a_					)
        feature_extractor.push_to_hub('test-feature-extractor' ,					use_auth_token=self._token					)

        SCREAMING_SNAKE_CASE_				:  Tuple           =     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					)

        SCREAMING_SNAKE_CASE_				:  str           =     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					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Tuple           =     WavaVecaFeatureExtractor.from_pretrained(a_					)
        feature_extractor.push_to_hub('valid_org/test-feature-extractor' ,					use_auth_token=self._token					)

        SCREAMING_SNAKE_CASE_				:  Any           =     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					)

        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     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					):





        """simple docstring"""







        CustomFeatureExtractor.register_for_auto_class()
        SCREAMING_SNAKE_CASE_				:  int           =     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'} ,					)

        SCREAMING_SNAKE_CASE_				:  List[Any]           =     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'					)









lowerCAmelCase     :   Tuple						     =  {
    'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
    'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
    'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
    'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
    '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
    '8': '---..', '9': '----.', '0': '-----', '&': '.-...', '@': '.--.-.',
    ':': '---...', ',': '--..--', '.': '.-.-.-', '\'': '.----.', '"': '.-..-.',
    '?': '..--..', '/': '-..-.', '=': '-...-', '+': '.-.-.', '-': '-....-',
    '(': '-.--.', ')': '-.--.-', '!': '-.-.--', ' ': '/'
}  # Exclamation mark is not in ITU-R recommendation
# fmt: on
lowerCAmelCase     :   Optional[int]						     =  {value: key for key, value in MORSE_CODE_DICT.items()}

def    A_  (							a  ):

      """simple docstring"""



      return " ".join(MORSE_CODE_DICT[char] for char in message.upper()  )

def    A_  (							a  ):

      """simple docstring"""



      return "".join(REVERSE_DICT[char] for char in message.split()  )

def    A_  (							):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  Tuple           =     'Morse code here!'
      print(a  )
      SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     encrypt(a  )
      print(a  )
      SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     decrypt(a  )
      print(a  )


if __name__ == "__main__":
    main()






