




lowerCamelCase__					:  str      							=				[
    'Audio',
    'Array2D',
    'Array3D',
    'Array4D',
    'Array5D',
    'ClassLabel',
    'Features',
    'Sequence',
    'Value',
    'Image',
    'Translation',
    'TranslationVariableLanguages',
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages





import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch





class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE   ):


 '''simple docstring'''







 @require_torch
 def  lowerCAmelCase_    (				self    :						int		):
       # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
       # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
       # while running an external program

       # python one-liner segments

       # this must be loaded before socket.socket is monkey-patched
       SCREAMING_SNAKE_CASE_      		=     '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

       # Force fetching the files so that we can use the cache
       SCREAMING_SNAKE_CASE_      		=     'hf-internal-testing/tiny-random-bert'
       BertConfig.from_pretrained(_lowerCAmelCase		)
       BertModel.from_pretrained(_lowerCAmelCase		)
       BertTokenizer.from_pretrained(_lowerCAmelCase		)
       pipeline(task='fill-mask'							,							model=_lowerCAmelCase		)

       # baseline - just load from_pretrained with normal network
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, run, mock]		)]

       # should succeed
       SCREAMING_SNAKE_CASE_      		=     self.get_env()
       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       SCREAMING_SNAKE_CASE_      		=     '1'
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)



 @require_torch
 def  lowerCAmelCase_    (				self    :						Tuple		):
       # python one-liner segments
       # this must be loaded before socket.socket is monkey-patched
       SCREAMING_SNAKE_CASE_      		=     '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

       # Force fetching the files so that we can use the cache
       SCREAMING_SNAKE_CASE_      		=     'hf-internal-testing/tiny-random-bert'
       BertConfig.from_pretrained(_lowerCAmelCase		)
       BertModel.from_pretrained(_lowerCAmelCase		)
       BertTokenizer.from_pretrained(_lowerCAmelCase		)
       pipeline(task='fill-mask'							,							model=_lowerCAmelCase		)

       # baseline - just load from_pretrained with normal network
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, run, mock]		)]

       # should succeed
       SCREAMING_SNAKE_CASE_      		=     self.get_env()
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)



 @require_torch
 def  lowerCAmelCase_    (				self    :						List[str]		):
       # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
       # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
       # while running an external program

       # python one-liner segments

       # this must be loaded before socket.socket is monkey-patched
       SCREAMING_SNAKE_CASE_      		=     '\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

       # baseline - just load from_pretrained with normal network
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, run]		)]

       # should succeed
       SCREAMING_SNAKE_CASE_      		=     self.get_env()
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)

       # next emulate no network
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, mock, run]		)]

       # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
       # env["TRANSFORMERS_OFFLINE"] = "0"
       # result = subprocess.run(cmd, env=env, check=False, capture_output=True)
       # self.assertEqual(result.returncode, 1, result.stderr)

       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       SCREAMING_SNAKE_CASE_      		=     '1'
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)



 @require_torch
 def  lowerCAmelCase_    (				self    :						Any		):
       SCREAMING_SNAKE_CASE_      		=     '\nfrom transformers import pipeline\n        '
       SCREAMING_SNAKE_CASE_      		=     '\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

       SCREAMING_SNAKE_CASE_      		=     '\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
       SCREAMING_SNAKE_CASE_      		=     self.get_env()
       SCREAMING_SNAKE_CASE_      		=     '1'
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, mock, run]		)]
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							1							,							result.stderr		)
       self.assertIn(
           'You cannot infer task automatically within `pipeline` when using offline mode'							,							result.stderr.decode().replace('\n'							,							''		)							,							)




 @require_torch
 def  lowerCAmelCase_    (				self    :						Optional[int]		):
       SCREAMING_SNAKE_CASE_      		=     '\nfrom transformers import AutoModel\n        '
       SCREAMING_SNAKE_CASE_      		=     '\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

       # baseline - just load from_pretrained with normal network
       SCREAMING_SNAKE_CASE_      		=     [sys.executable, '-c', '\n'.join([load, run]		)]

       # should succeed
       SCREAMING_SNAKE_CASE_      		=     self.get_env()
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)

       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       SCREAMING_SNAKE_CASE_      		=     '1'
       SCREAMING_SNAKE_CASE_      		=     subprocess.run(_lowerCAmelCase							,							env=_lowerCAmelCase							,							check=_lowerCAmelCase							,							capture_output=_lowerCAmelCase		)
       self.assertEqual(result.returncode							,							0							,							result.stderr		)
       self.assertIn('success'							,							result.stdout.decode()		)