


'''simple docstring'''




import subprocess
import sys

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

class 		UpperCAmelCase_      (  UpperCAmelCase__		):





     @require_torch
     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  str:
        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(__lowercase    )
        BertModel.from_pretrained(__lowercase    )
        BertTokenizer.from_pretrained(__lowercase    )
        pipeline(task='fill-mask'    ,      model=__lowercase    )

        # 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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        self.assertEqual(result.returncode    ,      0    ,      result.stderr    )
        self.assertIn('success'    ,      result.stdout.decode()    )





     @require_torch
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  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 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(__lowercase    )
        BertModel.from_pretrained(__lowercase    )
        BertTokenizer.from_pretrained(__lowercase    )
        pipeline(task='fill-mask'    ,      model=__lowercase    )

        # 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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        self.assertEqual(result.returncode    ,      0    ,      result.stderr    )
        self.assertIn('success'    ,      result.stdout.decode()    )





     @require_torch
     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  Any:
        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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        self.assertEqual(result.returncode    ,      0    ,      result.stderr    )
        self.assertIn('success'    ,      result.stdout.decode()    )





     @require_torch
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  int:
        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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        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 							__UpperCAmelCase      ( self       :      Tuple    )				->  Any:
        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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        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(__lowercase    ,      env=__lowercase    ,      check=__lowercase    ,      capture_output=__lowercase    )
        self.assertEqual(result.returncode    ,      0    ,      result.stderr    )
        self.assertIn('success'    ,      result.stdout.decode()    )











def 						lowerCamelCase__    (		):







	'''simple docstring'''





	snake_case_		    =     []
	snake_case_		    =     1

	while len(_A							) < 1E6:
		constant.append(str(_A							)							)
		i += 1

	snake_case_		    =     "".join(_A							)

	return (
	    int(constant[0]							)
	    * int(constant[9]							)
	    * int(constant[99]							)
	    * int(constant[999]							)
	    * int(constant[9999]							)
	    * int(constant[99999]							)
	    * int(constant[999999]							)
	)


if __name__ == "__main__":
		print(solution())
