

import subprocess
import sys

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





class    snake_case     (    __lowerCamelCase  ):

				@require_torch
				def 							lowercase_					(     self							:    Dict)->       str:



						'''simple docstring'''


						__lowerCAmelCase:	Union[str, Any]   				=      "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

						__lowerCAmelCase:	str   				=      "\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        "

						__lowerCAmelCase:	Dict   				=      "\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
						__lowerCAmelCase:	List[Any]   				=      "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
						__lowerCAmelCase:	Tuple   				=      [sys.executable, "-c", "\n".join([load, run, mock])]

						# should succeed
						__lowerCAmelCase:	Tuple   				=      self.get_env()
						# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
						__lowerCAmelCase:	Optional[Any]   				=      "1"
						__lowerCAmelCase:	Any   				=      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 							lowercase_					(     self							:    Tuple)->       int:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[int]   				=      "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

						__lowerCAmelCase:	Optional[Any]   				=      "\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        "

						__lowerCAmelCase:	Dict   				=      "\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
						__lowerCAmelCase:	Optional[Any]   				=      "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
						__lowerCAmelCase:	Tuple   				=      [sys.executable, "-c", "\n".join([load, run, mock])]

						# should succeed
						__lowerCAmelCase:	List[Any]   				=      self.get_env()
						__lowerCAmelCase:	Dict   				=      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 							lowercase_					(     self							:    Optional[int])->       Union[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[Any]   				=      "\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        "

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

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

						# should succeed
						__lowerCAmelCase:	List[str]   				=      self.get_env()
						__lowerCAmelCase:	str   				=      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
						__lowerCAmelCase:	Optional[Any]   				=      [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
						__lowerCAmelCase:	Optional[int]   				=      "1"
						__lowerCAmelCase:	Tuple   				=      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 							lowercase_					(     self							:    str)->       str:



						'''simple docstring'''


						__lowerCAmelCase:	List[str]   				=      "\nfrom transformers import pipeline\n        "
						__lowerCAmelCase:	Union[str, Any]   				=      "\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n        "

						__lowerCAmelCase:	int   				=      "\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")\nsocket.socket = offline_socket\n        "
						__lowerCAmelCase:	Tuple   				=      self.get_env()
						__lowerCAmelCase:	Dict   				=      "1"
						__lowerCAmelCase:	Dict   				=      [sys.executable, "-c", "\n".join([load, mock, run])]
						__lowerCAmelCase:	Any   				=      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 							lowercase_					(     self							:    Tuple)->       Tuple:



						'''simple docstring'''


						__lowerCAmelCase:	int   				=      "\nfrom transformers import AutoModel\n        "
						__lowerCAmelCase:	str   				=      "\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
						__lowerCAmelCase:	Dict   				=      [sys.executable, "-c", "\n".join([load, run])]

						# should succeed
						__lowerCAmelCase:	Dict   				=      self.get_env()
						__lowerCAmelCase:	Dict   				=      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
						__lowerCAmelCase:	Optional[Any]   				=      "1"
						__lowerCAmelCase:	Optional[int]   				=      subprocess.run(UpperCamelCase_					,  env=UpperCamelCase_					,  check=UpperCamelCase_					,  capture_output=UpperCamelCase_)
						self.assertEqual(result.returncode					,  0					,  result.stderr)
						self.assertIn("success"					,  result.stdout.decode())





"""simple docstring"""


def    a__   (   __SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE			)     ->     int:
		return int((input_a, input_a).count(0			) == 0			)






def    a__   (   )     ->     None:
		assert and_gate(0 ,			0			) == 0
		assert and_gate(0 ,			1			) == 0
		assert and_gate(1 ,			0			) == 0
		assert and_gate(1 ,			1			) == 1


if __name__ == "__main__":
			test_and_gate()
			print(and_gate(1, 0))
			print(and_gate(0, 0))
			print(and_gate(0, 1))
			print(and_gate(1, 1))


