

"""simple docstring"""






from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching





def 	lowercase      (   ) ->      Union[str, Any]:
 import os as original_os
 from os import path as original_path
 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join

 __magic_name__     =      '''__test_patch_submodule_mock__'''
 with patch_submodule(_test_patching      ,   '''os.path.join'''      ,   __UpperCamelCase						):
  # Every way to access os.path.join must be patched, and the rest must stay untouched

  # check os.path.join
  assert isinstance(_test_patching.os      ,   _PatchedModuleObj						)
  assert isinstance(_test_patching.os.path      ,   _PatchedModuleObj						)
  assert _test_patching.os.path.join is mock

  # check path.join
  assert isinstance(_test_patching.path      ,   _PatchedModuleObj						)
  assert _test_patching.path.join is mock

  # check join
  assert _test_patching.join is mock

  # check that the other attributes are untouched
  assert _test_patching.os.rename is original_rename
  assert _test_patching.path.dirname is original_dirname
  assert _test_patching.os.path.dirname is original_dirname

  # Even renamed modules or objects must be patched

  # check renamed_os.path.join
  assert isinstance(_test_patching.renamed_os      ,   _PatchedModuleObj						)
  assert isinstance(_test_patching.renamed_os.path      ,   _PatchedModuleObj						)
  assert _test_patching.renamed_os.path.join is mock

  # check renamed_path.join
  assert isinstance(_test_patching.renamed_path      ,   _PatchedModuleObj						)
  assert _test_patching.renamed_path.join is mock

  # check renamed_join
  assert _test_patching.renamed_join is mock

  # check that the other attributes are untouched
  assert _test_patching.renamed_os.rename is original_rename
  assert _test_patching.renamed_path.dirname is original_dirname
  assert _test_patching.renamed_os.path.dirname is original_dirname

 # check that everthing is back to normal when the patch is over

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join





def 	lowercase      (   ) ->      List[str]:
 assert _test_patching.open is open

 __magic_name__     =      '''__test_patch_submodule_builtin_mock__'''
 # _test_patching has "open" in its globals
 assert _test_patching.open is open
 with patch_submodule(_test_patching      ,   '''open'''      ,   __UpperCamelCase						):
  assert _test_patching.open is mock

 # check that everthing is back to normal when the patch is over

 assert _test_patching.open is open





def 	lowercase      (   ) ->      Tuple:
 # pandas.read_csv is not present in _test_patching
 __magic_name__     =      '''__test_patch_submodule_missing_mock__'''
 with patch_submodule(_test_patching      ,   '''pandas.read_csv'''      ,   __UpperCamelCase						):
  pass





def 	lowercase      (   ) ->      Tuple:
 # builtin should always be mocked even if they're not in the globals
 # in case they're loaded at one point
 __magic_name__     =      '''__test_patch_submodule_missing_builtin_mock__'''
 # _test_patching doesn't have "len" in its globals
 assert getattr(_test_patching      ,   '''len'''      ,   __UpperCamelCase						) is None
 with patch_submodule(_test_patching      ,   '''len'''      ,   __UpperCamelCase						):
  assert _test_patching.len is mock
 assert _test_patching.len is len





def 	lowercase      (   ) ->      int:
 __magic_name__     =      '''__test_patch_submodule_start_and_stop_mock__'''
 __magic_name__     =      patch_submodule(_test_patching      ,   '''open'''      ,   __UpperCamelCase						)
 assert _test_patching.open is open
 patch.start()
 assert _test_patching.open is mock
 patch.stop()
 assert _test_patching.open is open





def 	lowercase      (   ) ->      str:
 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 __magic_name__     =      '''__test_patch_submodule_successive_join__'''
 __magic_name__     =      '''__test_patch_submodule_successive_dirname__'''
 __magic_name__     =      '''__test_patch_submodule_successive_rename__'''
 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename

 with patch_submodule(_test_patching      ,   '''os.path.join'''      ,   __UpperCamelCase						):
  with patch_submodule(_test_patching      ,   '''os.rename'''      ,   __UpperCamelCase						):
   with patch_submodule(_test_patching      ,   '''os.path.dirname'''      ,   __UpperCamelCase						):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

    # try another order
 with patch_submodule(_test_patching      ,   '''os.rename'''      ,   __UpperCamelCase						):
  with patch_submodule(_test_patching      ,   '''os.path.join'''      ,   __UpperCamelCase						):
   with patch_submodule(_test_patching      ,   '''os.path.dirname'''      ,   __UpperCamelCase						):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename





def 	lowercase      (   ) ->      Optional[int]:
 __magic_name__     =      '''__test_patch_submodule_doesnt_exist_mock__'''
 with patch_submodule(_test_patching      ,   '''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''      ,   __UpperCamelCase						):
  pass
 with patch_submodule(_test_patching      ,   '''os.__attribute_that_doesn_exist__'''      ,   __UpperCamelCase						):
  pass




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


__lowerCamelCase										=		"hf-internal-testing/tiny-random-bert"
__lowerCamelCase										=		os.path.join(TRANSFORMERS_CACHE, "models--hf-internal-testing--tiny-random-bert")
__lowerCamelCase										=		"9b8c223d42b2188cb49d29af482996f9d0f3e5a6"
class        _lowercase					(     unittest.TestCase     ):







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      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:
       __magic_name__     =      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.
      __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_       )
      self.assertEqual(UpperCamelCase_ ,						UpperCamelCase_       )

      # Using a specific revision to test the full commit hash.
      __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_ ,						revision='''9b8c223'''       )
      self.assertEqual(UpperCamelCase_ ,						os.path.join(UpperCamelCase_ ,						'''snapshots''' ,						UpperCamelCase_ ,						UpperCamelCase_       )       )







     def 	lowerCAmelCase__    (      self       ):
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid model identifier'''       ):
       __magic_name__     =      cached_file('''tiny-random-bert''' ,						UpperCamelCase_       )

      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid git identifier'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_ ,						revision='''aaaa'''       )

      with self.assertRaisesRegex(UpperCamelCase_ ,						'''does not appear to have a file named'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf'''       )







     def 	lowerCAmelCase__    (      self       ):
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''does not appear to have a file named'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf'''       )

      with open(os.path.join(UpperCamelCase_ ,						'''refs''' ,						'''main'''       )       ) as f:
       __magic_name__     =      f.read()
      self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase_ ,						'''.no_exist''' ,						UpperCamelCase_ ,						'''conf'''       )       )       )

      __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf''' ,						_raise_exceptions_for_missing_entries=UpperCamelCase_       )
      self.assertIsNone(UpperCamelCase_       )

      __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf''' ,						local_files_only=UpperCamelCase_ ,						_raise_exceptions_for_missing_entries=UpperCamelCase_       )
      self.assertIsNone(UpperCamelCase_       )

      __magic_name__     =      mock.Mock()
      __magic_name__     =      500
      __magic_name__     =      {}
      __magic_name__     =      HTTPError
      __magic_name__     =      {}

      # 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:
       __magic_name__     =      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       ):
      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       ):
      # `get_file_from_repo` returns None if the file does not exist
      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'''       )

      __magic_name__     =      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.
      __magic_name__     =      json.loads(open(UpperCamelCase_ ,						'''r'''       ).read()       )
      self.assertEqual(config['''hidden_size'''] ,						768       )







     def 	lowerCAmelCase__    (      self       ):
      with tempfile.TemporaryDirectory() as tmp_dir:
       __magic_name__     =      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'''       )       )

