

"""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


UpperCAmelCase													=get_tests_dir("fixtures")





class lowerCamelCase__   (				unittest.TestCase    ):



    '''simple docstring'''




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

          # Download this model to make sure it's in the cache.
          A				  =		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:
                A				  =		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    )    ->      Dict:
          # This test is for deprecated behavior and can be removed in v5
          A				  =		WavaVecaFeatureExtractor.from_pretrained(
              """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"""    )





@is_staging_test
class lowerCamelCase__   (				unittest.TestCase    ):



    '''simple docstring'''




    @classmethod
    def UpperCamelCase__		( cls    )    ->      Tuple:
          A				  =		TOKEN
          HfFolder.save_token(lowerCamelCase_    )




    @classmethod
    def UpperCamelCase__		( cls    )    ->      Tuple:
          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[int]:
          A				  =		WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase_    )
          feature_extractor.push_to_hub("""test-feature-extractor""" ,use_auth_token=self._token    )

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

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




    def UpperCamelCase__		( self    )    ->      Any:
          A				  =		WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase_    )
          feature_extractor.push_to_hub("""valid_org/test-feature-extractor""" ,use_auth_token=self._token    )

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

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




    def UpperCamelCase__		( self    )    ->      Any:
          CustomFeatureExtractor.register_for_auto_class()
          A				  =		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"""} ,)

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







"""simple docstring"""


import re

from filelock import FileLock


try:
  import nltk

  UpperCAmelCase													=True
except (ImportError, ModuleNotFoundError):
  UpperCAmelCase													=False

if NLTK_AVAILABLE:
  with FileLock(".lock") as lock:
    nltk.download("punkt", quiet=True)



def   _A					(	_a	:						str				):



      """simple docstring"""






      re.sub("""<n>"""     ,   """"""     ,   _a				)  # remove pegasus newline char
      assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)"
      return "\n".join(nltk.sent_tokenize(_a				)				)




