





'''simple docstring'''




import subprocess
import sys

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


class 					SCREAMING_SNAKE_CASE       (a__				):


     @require_torch
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

          __A		:					List[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        '

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

          # should succeed
          __A		:					List[str]						=			self.get_env()
          # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
          __A		:					Optional[Any]						=			'1'
          __A		:					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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Any						=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

          __A		:					Optional[int]						=			'\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		:					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
          __A		:					int						=			'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		:					Tuple						=			[sys.executable, '-c', '\n'.join([load, run, mock])]

          # should succeed
          __A		:					Dict						=			self.get_env()
          __A		:					Optional[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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

          __A		:					List[str]						=			'\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

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

          # should succeed
          __A		:					List[Any]						=			self.get_env()
          __A		:					List[Any]						=			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		:					Dict						=			[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		:					Union[str, Any]						=			'1'
          __A		:					Union[str, 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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






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

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

          '''simple docstring'''






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

          # should succeed
          __A		:					int						=			self.get_env()
          __A		:					Optional[Any]						=			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		:					List[str]						=			'1'
          __A		:					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 			_lowerCAmelCase     (    __snake_case    :					str					,				__snake_case    :					str     )	->	int:
     if len(__snake_case     ) != len(__snake_case     ):
          raise ValueError('String lengths must match!'     )

     __A		:					Optional[Any]						=			0

     for chara, chara in zip(__snake_case					,				__snake_case     ):
          if chara != chara:
               count += 1

     return count


if __name__ == "__main__":
  import doctest

  doctest.testmod()