



"""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						:		Any			= get_tests_dir("fixtures")


class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      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=lowerCAmelCase_) 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):







      """simple docstring"""







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







@is_staging_test
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    @classmethod
    def 					_UpperCAmelCase	(				cls			:				str):







      """simple docstring"""







      lowercase_								= TOKEN
      HfFolder.save_token(lowerCAmelCase_)

    @classmethod
    def 					_UpperCAmelCase	(				cls			:				Any):







      """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			:				Dict):







      """simple docstring"""







      lowercase_								= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase_)
      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(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)

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







      """simple docstring"""







      lowercase_								= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase_)
      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(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)

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







      """simple docstring"""







      CustomFeatureExtractor.register_for_auto_class()
      lowercase_								= 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"""} ,  )

      lowercase_								= 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 os
from collections.abc import Iterator


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase = "."							) ->						Iterator[str]:







  '''simple docstring'''


  for dir_path, dir_names, filenames in os.walk(__lowerCAmelCase							):
    lowercase_								= [d for d in dir_names if d != """scripts""" and d[0] not in """._"""]
    for filename in filenames:
      if filename == "__init__.py":
        continue
      if os.path.splitext(__lowerCAmelCase							)[1] in (".py", ".ipynb"):
        yield os.path.join(__lowerCAmelCase ,  __lowerCAmelCase							).lstrip("""./"""							)


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase							) ->						Any:







  '''simple docstring'''


  return F'''{i * "  "}*''' if i else "\n##"


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase							) ->						str:







  '''simple docstring'''


  lowercase_								= old_path.split(os.sep							)
  for i, new_part in enumerate(new_path.split(os.sep							)							):
    if (i + 1 > len(__lowerCAmelCase							) or old_parts[i] != new_part) and new_part:
      print(F'''{md_prefix(__lowerCAmelCase							)} {new_part.replace("_" ,  " "							).title()}'''							)
  return new_path


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase = "."							) ->						None:







  '''simple docstring'''


  lowercase_								= """"""
  for filepath in sorted(good_file_paths(__lowerCAmelCase							)							):
    lowercase_					,    lowercase_								= os.path.split(__lowerCAmelCase							)
    if filepath != old_path:
      lowercase_								= print_path(__lowerCAmelCase ,  __lowerCAmelCase							)
    lowercase_								= (filepath.count(os.sep							) + 1) if filepath else 0
    lowercase_								= F'''{filepath}/{filename}'''.replace(""" """ ,  """%20"""							)
    lowercase_								= os.path.splitext(filename.replace("""_""" ,  """ """							).title()							)[0]
    print(F'''{md_prefix(__lowerCAmelCase							)} [{filename}]({url})'''							)


if __name__ == "__main__":
       print_directory_md(".")

