

'''simple docstring'''







import subprocess
import sys

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


class 					A__      (      _snake_case			):



    @require_torch
    def 					snake_case_			(					self       )						->      Dict:





           '''simple docstring'''
           # 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
           A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

           A_						=      """
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

           A_						=      """
import socket
def offline_socket(*args, **kwargs): raise RuntimeError(\"Offline mode is enabled, we shouldn't access internet\")
socket.socket = offline_socket
        """

           # Force fetching the files so that we can use the cache
           A_						=      """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_						=      [sys.executable, """-c""", """\n""".join([load, run, mock]       )]

           # should succeed
           A_						=      self.get_env()
           # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
           A_						=      """1"""
           A_						=      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 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           # python one-liner segments
           # this must be loaded before socket.socket is monkey-patched
           A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

           A_						=      """
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

           A_						=      """
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Faking flaky internet\")
socket.socket = offline_socket
        """

           # Force fetching the files so that we can use the cache
           A_						=      """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_						=      [sys.executable, """-c""", """\n""".join([load, run, mock]       )]

           # should succeed
           A_						=      self.get_env()
           A_						=      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 					snake_case_			(					self       )						->      Optional[int]:





           '''simple docstring'''
           # 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
           A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer
        """

           A_						=      """
mname = \"hf-internal-testing/tiny-random-bert-sharded\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print(\"success\")
        """

           A_						=      """
import socket
def offline_socket(*args, **kwargs): raise ValueError(\"Offline mode is enabled\")
socket.socket = offline_socket
        """

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

           # should succeed
           A_						=      self.get_env()
           A_						=      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_						=      [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_						=      """1"""
           A_						=      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 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      """
from transformers import pipeline
        """
           A_						=      """
mname = \"hf-internal-testing/tiny-random-bert\"
pipe = pipeline(model=mname)
        """

           A_						=      """
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")
socket.socket = offline_socket
        """
           A_						=      self.get_env()
           A_						=      """1"""
           A_						=      [sys.executable, """-c""", """\n""".join([load, mock, run]       )]
           A_						=      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 					snake_case_			(					self       )						->      Optional[int]:





           '''simple docstring'''
           A_						=      """
from transformers import AutoModel
        """
           A_						=      """
mname = \"hf-internal-testing/test_dynamic_model\"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print(\"success\")
        """

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

           # should succeed
           A_						=      self.get_env()
           A_						=      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_						=      """1"""
           A_						=      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       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__ = 0,       UpperCAmelCase__ = 0				)			->			int:
       A_						=      right or len(UpperCAmelCase__				) - 1
       if left > right:
              return -1
       elif list_data[left] == key:
              return left
       elif list_data[right] == key:
              return right
       else:
              return search(UpperCAmelCase__,       UpperCAmelCase__,       left + 1,       right - 1				)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
