


"""simple docstring"""



import json
import os
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from requests.exceptions import HTTPError

from transformers.utils import (
    CONFIG_NAME,
    FLAX_WEIGHTS_NAME,
    TF2_WEIGHTS_NAME,
    TRANSFORMERS_CACHE,
    WEIGHTS_NAME,
    cached_file,
    get_file_from_repo,
    has_file,
)


__snake_case       =       """hf-internal-testing/tiny-random-bert"""
__snake_case       =       os.path.join(TRANSFORMERS_CACHE, """models--hf-internal-testing--tiny-random-bert""")
__snake_case       =       """9b8c223d42b2188cb49d29af482996f9d0f3e5a6"""







class _lowerCAmelCase							( unittest.TestCase      ):







   def 					lowerCamelCase						(      self		)      ->						Union[str, Any]:

       '''simple docstring'''




       snake_case       : str    =       cached_file(UpperCamelCase__		,      UpperCamelCase__		)
       # Should have downloaded the file in here
       self.assertTrue(os.path.isdir(UpperCamelCase__		)		)
       # Cache should contain at least those three subfolders:
       for subfolder in ["blobs", "refs", "snapshots"]:
           self.assertTrue(os.path.isdir(os.path.join(UpperCamelCase__		,      UpperCamelCase__		)		)		)
       with open(os.path.join(UpperCamelCase__		,      "refs"		,      "main"		)		) as f:
           snake_case       : Tuple    =       f.read()
       self.assertEqual(UpperCamelCase__		,      os.path.join(UpperCamelCase__		,      "snapshots"		,      UpperCamelCase__		,      UpperCamelCase__		)		)
       self.assertTrue(os.path.isfile(UpperCamelCase__		)		)

       # File is cached at the same place the second time.
       snake_case       : List[Any]    =       cached_file(UpperCamelCase__		,      UpperCamelCase__		)
       self.assertEqual(UpperCamelCase__		,      UpperCamelCase__		)

       # Using a specific revision to test the full commit hash.
       snake_case       : str    =       cached_file(UpperCamelCase__		,      UpperCamelCase__		,      revision="9b8c223"		)
       self.assertEqual(UpperCamelCase__		,      os.path.join(UpperCamelCase__		,      "snapshots"		,      UpperCamelCase__		,      UpperCamelCase__		)		)







   def 					lowerCamelCase						(      self		)      ->						Tuple:

       '''simple docstring'''




       with self.assertRaisesRegex(UpperCamelCase__		,      "is not a valid model identifier"		):
           snake_case       : int    =       cached_file("tiny-random-bert"		,      UpperCamelCase__		)

       with self.assertRaisesRegex(UpperCamelCase__		,      "is not a valid git identifier"		):
           snake_case       : Union[str, Any]    =       cached_file(UpperCamelCase__		,      UpperCamelCase__		,      revision="aaaa"		)

       with self.assertRaisesRegex(UpperCamelCase__		,      "does not appear to have a file named"		):
           snake_case       : str    =       cached_file(UpperCamelCase__		,      "conf"		)







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       with self.assertRaisesRegex(UpperCamelCase__		,      "does not appear to have a file named"		):
           snake_case       : Dict    =       cached_file(UpperCamelCase__		,      "conf"		)

       with open(os.path.join(UpperCamelCase__		,      "refs"		,      "main"		)		) as f:
           snake_case       : Union[str, Any]    =       f.read()
       self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__		,      ".no_exist"		,      UpperCamelCase__		,      "conf"		)		)		)

       snake_case       : Optional[int]    =       cached_file(UpperCamelCase__		,      "conf"		,      _raise_exceptions_for_missing_entries=UpperCamelCase__		)
       self.assertIsNone(UpperCamelCase__		)

       snake_case       : Union[str, Any]    =       cached_file(UpperCamelCase__		,      "conf"		,      local_files_only=UpperCamelCase__		,      _raise_exceptions_for_missing_entries=UpperCamelCase__		)
       self.assertIsNone(UpperCamelCase__		)

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

       # Under the mock environment we get a 500 error when trying to reach the tokenizer.
       with mock.patch("requests.Session.request"		,      return_value=UpperCamelCase__		) as mock_head:
           snake_case       : int    =       cached_file(UpperCamelCase__		,      "conf"		,      _raise_exceptions_for_connection_errors=UpperCamelCase__		)
           self.assertIsNone(UpperCamelCase__		)
           # This check we did call the fake head request
           mock_head.assert_called()







   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       self.assertTrue(has_file("hf-internal-testing/tiny-bert-pt-only"		,      UpperCamelCase__		)		)
       self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"		,      UpperCamelCase__		)		)
       self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"		,      UpperCamelCase__		)		)







   def 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       self.assertIsNone(get_file_from_repo("bert-base-cased"		,      "ahah.txt"		)		)

       # The function raises if the repository does not exist.
       with self.assertRaisesRegex(UpperCamelCase__		,      "is not a valid model identifier"		):
           get_file_from_repo("bert-base-case"		,      UpperCamelCase__		)

       # The function raises if the revision does not exist.
       with self.assertRaisesRegex(UpperCamelCase__		,      "is not a valid git identifier"		):
           get_file_from_repo("bert-base-cased"		,      UpperCamelCase__		,      revision="ahaha"		)

       snake_case       : Any    =       get_file_from_repo("bert-base-cased"		,      UpperCamelCase__		)
       # The name is the cached name which is not very easy to test, so instead we load the content.
       snake_case       : Any    =       json.loads(open(UpperCamelCase__		,      "r"		).read()		)
       self.assertEqual(config["hidden_size"]		,      768		)







   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case       : Dict    =       Path(UpperCamelCase__		) / "a.txt"
           filename.touch()
           self.assertEqual(get_file_from_repo(UpperCamelCase__		,      "a.txt"		)		,      str(UpperCamelCase__		)		)

           self.assertIsNone(get_file_from_repo(UpperCamelCase__		,      "b.txt"		)		)









"""simple docstring"""



from .imports import is_tqdm_available


if is_tqdm_available():
  from tqdm.auto import tqdm as _tqdm

from ..state import PartialState







def     __lowerCAmelCase		(		lowercase    :    bool = True		,				*lowercase    :    str		,				**lowercase    :    List[Any]					)      ->		List[Any]:


    """simple docstring"""





    if not is_tqdm_available():
        raise ImportError("Accelerate's `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`."					)
    snake_case       : Dict    =       False
    if main_process_only:
        snake_case       : int    =       PartialState().local_process_index == 0
    return _tqdm(*lowercase		,				**lowercase		,				disable=lowercase					)





