import subprocess
import sys

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


class 						a__							(       __snake_case		):



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Dict:
								# 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
								__a		 =       '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

								__a		 =       '\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        '

								__a		 =       '\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
								__a		 =       'hf-internal-testing/tiny-random-bert'
								BertConfig.from_pretrained(UpperCAmelCase   )
								BertModel.from_pretrained(UpperCAmelCase   )
								BertTokenizer.from_pretrained(UpperCAmelCase   )
								pipeline(task='fill-mask'				,						model=UpperCAmelCase   )

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

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



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								# python one-liner segments
								# this must be loaded before socket.socket is monkey-patched
								__a		 =       '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

								__a		 =       '\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        '

								__a		 =       '\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
								__a		 =       'hf-internal-testing/tiny-random-bert'
								BertConfig.from_pretrained(UpperCAmelCase   )
								BertModel.from_pretrained(UpperCAmelCase   )
								BertTokenizer.from_pretrained(UpperCAmelCase   )
								pipeline(task='fill-mask'				,						model=UpperCAmelCase   )

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

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



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[Any]:
								# 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
								__a		 =       '\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

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

								__a		 =       '\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
								__a		 =       [sys.executable, '-c', '\n'.join([load, run]   )]

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

								# next emulate no network
								__a		 =       [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
								__a		 =       '1'
								__a		 =       subprocess.run(UpperCAmelCase				,						env=UpperCAmelCase				,						check=UpperCAmelCase				,						capture_output=UpperCAmelCase   )
								self.assertEqual(result.returncode				,						0				,						result.stderr   )
								self.assertIn('success'				,						result.stdout.decode()   )



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       '\nfrom transformers import pipeline\n        '
								__a		 =       '\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

								__a		 =       '\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
								__a		 =       self.get_env()
								__a		 =       '1'
								__a		 =       [sys.executable, '-c', '\n'.join([load, mock, run]   )]
								__a		 =       subprocess.run(UpperCAmelCase				,						env=UpperCAmelCase				,						check=UpperCAmelCase				,						capture_output=UpperCAmelCase   )
								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 __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       '\nfrom transformers import AutoModel\n        '
								__a		 =       '\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
								__a		 =       [sys.executable, '-c', '\n'.join([load, run]   )]

								# should succeed
								__a		 =       self.get_env()
								__a		 =       subprocess.run(UpperCAmelCase				,						env=UpperCAmelCase				,						check=UpperCAmelCase				,						capture_output=UpperCAmelCase   )
								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
								__a		 =       '1'
								__a		 =       subprocess.run(UpperCAmelCase				,						env=UpperCAmelCase				,						check=UpperCAmelCase				,						capture_output=UpperCAmelCase   )
								self.assertEqual(result.returncode				,						0				,						result.stderr   )
								self.assertIn('success'				,						result.stdout.decode()   )





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase_    :		Optional[int]							=	{"""configuration_xlnet""": ["""XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLNetConfig"""]}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		str							=	["""XLNetTokenizer"""]

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Optional[Any]							=	["""XLNetTokenizerFast"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Union[str, Any]							=	[
	    """XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """XLNetForMultipleChoice""",
	    """XLNetForQuestionAnswering""",
	    """XLNetForQuestionAnsweringSimple""",
	    """XLNetForSequenceClassification""",
	    """XLNetForTokenClassification""",
	    """XLNetLMHeadModel""",
	    """XLNetModel""",
	    """XLNetPreTrainedModel""",
	    """load_tf_weights_in_xlnet""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Optional[int]							=	[
	    """TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """TFXLNetForMultipleChoice""",
	    """TFXLNetForQuestionAnsweringSimple""",
	    """TFXLNetForSequenceClassification""",
	    """TFXLNetForTokenClassification""",
	    """TFXLNetLMHeadModel""",
	    """TFXLNetMainLayer""",
	    """TFXLNetModel""",
	    """TFXLNetPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlnet import XLNetTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlnet_fast import XLNetTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_xlnet import (
		    XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XLNetForMultipleChoice,
		    XLNetForQuestionAnswering,
		    XLNetForQuestionAnsweringSimple,
		    XLNetForSequenceClassification,
		    XLNetForTokenClassification,
		    XLNetLMHeadModel,
		    XLNetModel,
		    XLNetPreTrainedModel,
		    load_tf_weights_in_xlnet,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_xlnet import (
		    TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFXLNetForMultipleChoice,
		    TFXLNetForQuestionAnsweringSimple,
		    TFXLNetForSequenceClassification,
		    TFXLNetForTokenClassification,
		    TFXLNetLMHeadModel,
		    TFXLNetMainLayer,
		    TFXLNetModel,
		    TFXLNetPreTrainedModel,
		)

else:
	import sys

	lowerCamelCase_    :		Tuple							=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




