
"""simple docstring"""







import subprocess
import sys

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







class 							__magic_name__     (		lowercase__   ):





					@require_torch
					def 							lowerCAmelCase      (				self   :							Tuple    ):
												# 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
												__snake_case     			=       "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

												__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        "

												__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
												__snake_case     			=       "hf-internal-testing/tiny-random-bert"
												BertConfig.from_pretrained(snake_case_    )
												BertModel.from_pretrained(snake_case_    )
												BertTokenizer.from_pretrained(snake_case_    )
												pipeline(task="fill-mask"							,						model=snake_case_    )

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

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





					@require_torch
					def 							lowerCAmelCase      (				self   :							List[Any]    ):
												# python one-liner segments
												# this must be loaded before socket.socket is monkey-patched
												__snake_case     			=       "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

												__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        "

												__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
												__snake_case     			=       "hf-internal-testing/tiny-random-bert"
												BertConfig.from_pretrained(snake_case_    )
												BertModel.from_pretrained(snake_case_    )
												BertTokenizer.from_pretrained(snake_case_    )
												pipeline(task="fill-mask"							,						model=snake_case_    )

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

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





					@require_torch
					def 							lowerCAmelCase      (				self   :							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
												__snake_case     			=       "\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        "

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

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

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

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





					@require_torch
					def 							lowerCAmelCase      (				self   :							str    ):
												__snake_case     			=       "\nfrom transformers import pipeline\n        "
												__snake_case     			=       "\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n        "

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

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


"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_SCREAMING_SNAKE_CASE	       =      {
    """configuration_mobilevit""": ["""MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MobileViTConfig""", """MobileViTOnnxConfig"""],
}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE	       =      ["""MobileViTFeatureExtractor"""]
		_SCREAMING_SNAKE_CASE	       =      ["""MobileViTImageProcessor"""]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE	       =      [
		    """MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """MobileViTForImageClassification""",
		    """MobileViTForSemanticSegmentation""",
		    """MobileViTModel""",
		    """MobileViTPreTrainedModel""",
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE	       =      [
		    """TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """TFMobileViTForImageClassification""",
		    """TFMobileViTForSemanticSegmentation""",
		    """TFMobileViTModel""",
		    """TFMobileViTPreTrainedModel""",
		]

if TYPE_CHECKING:
		from .configuration_mobilevit import MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileViTConfig, MobileViTOnnxConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_mobilevit import MobileViTFeatureExtractor
				from .image_processing_mobilevit import MobileViTImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_mobilevit import (
				    MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    MobileViTForImageClassification,
				    MobileViTForSemanticSegmentation,
				    MobileViTModel,
				    MobileViTPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_mobilevit import (
				    TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFMobileViTForImageClassification,
				    TFMobileViTForSemanticSegmentation,
				    TFMobileViTModel,
				    TFMobileViTPreTrainedModel,
				)


else:
		import sys

		_SCREAMING_SNAKE_CASE	       =      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
