






'''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__						:List[str]          =			get_tests_dir("""fixtures""")







class 	SCREAMING_SNAKE_CASE	(      unittest.TestCase  ):




       def 					a_					(					self      : int					):


            """simple docstring"""







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

            # Download this model to make sure it's in the cache.
            __lowerCamelCase						:       Dict				   =				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:
                 __lowerCamelCase						:       Optional[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      : Optional[int]					):


            """simple docstring"""







            __lowerCamelCase						:       Optional[int]				   =				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 					a_					(					cls      : Tuple					):


            """simple docstring"""







            __lowerCamelCase						:       Optional[int]				   =				TOKEN
            HfFolder.save_token(A__					)




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


            """simple docstring"""







            __lowerCamelCase						:       Union[str, Any]				   =				WavaVecaFeatureExtractor.from_pretrained(A__					)
            feature_extractor.push_to_hub("""test-feature-extractor"""	,    use_auth_token=self._token					)

            __lowerCamelCase						:       List[str]				   =				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					)

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




       def 					a_					(					self      : List[Any]					):


            """simple docstring"""







            __lowerCamelCase						:       List[Any]				   =				WavaVecaFeatureExtractor.from_pretrained(A__					)
            feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""	,    use_auth_token=self._token					)

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

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




       def 					a_					(					self      : int					):


            """simple docstring"""







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

            __lowerCamelCase						:       int				   =				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'''

import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     Optional[Any]:


     """simple docstring"""
     # Initialise PyTorch model
     __lowerCamelCase						:       str				   =				RemBertConfig.from_json_file(_lowercase     )
     print("""Building PyTorch model from configuration: {}""".format(str(_lowercase     )     )     )
     __lowerCamelCase						:       List[Any]				   =				RemBertModel(_lowercase     )

     # Load weights from tf checkpoint
     load_tf_weights_in_rembert(_lowercase,						_lowercase,						_lowercase     )

     # Save pytorch-model
     print("""Save PyTorch model to {}""".format(_lowercase     )     )
     torch.save(model.state_dict(),						_lowercase     )


if __name__ == "__main__":
   UpperCAmelCase__						:Tuple          =			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
   )
   parser.add_argument(
       """--rembert_config_file""",
       default=None,
       type=str,
       required=True,
       help=(
           """The config json file corresponding to the pre-trained RemBERT model. \n"""
           """This specifies the model architecture."""
       ),
   )
   parser.add_argument(
       """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   UpperCAmelCase__						:List[Any]          =			parser.parse_args()
   convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)



