
import subprocess
import sys

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





class       __A(				UpperCAmelCase       ):

					@require_torch
					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_							  =					"""\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        """

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

												# should succeed
												lowerCamelCase_							  =					self.get_env()
												# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
												lowerCamelCase_							  =					"""1"""
												lowerCamelCase_							  =					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					:     int   ):
												lowerCamelCase_							  =					"""\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        """

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

												# should succeed
												lowerCamelCase_							  =					self.get_env()
												lowerCamelCase_							  =					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					:     Dict   ):
												lowerCamelCase_							  =					"""\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        """

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

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

												# should succeed
												lowerCamelCase_							  =					self.get_env()
												lowerCamelCase_							  =					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_							  =					[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_							  =					"""1"""
												lowerCamelCase_							  =					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   ):
												lowerCamelCase_							  =					"""\nfrom transformers import pipeline\n        """
												lowerCamelCase_							  =					"""\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n        """

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

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







def      __lowerCAmelCase						(							UpperCAmelCase__				:      int = 4_0_0_0_0_0_0       )  ->    int:
							lowerCamelCase_							  =					[]
							lowerCamelCase_  ,   lowerCamelCase_							  =					0, 1
							while b <= n:
														if b % 2 == 0:
																					even_fibs.append(UpperCAmelCase__       )
														lowerCamelCase_  ,   lowerCamelCase_							  =					b, a + b
							return sum(UpperCAmelCase__       )


if __name__ == "__main__":
		print(F"""{solution() = }""")





