import subprocess
import sys

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






class 		_lowerCamelCase		( UpperCamelCase_     ):
    @require_torch
    def     UpperCamelCase_					(	self )							->       Any:
     # 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
     SCREAMING_SNAKE_CASE__: Any=   '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        '''

     SCREAMING_SNAKE_CASE__: List[Any]=   '''
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")
        '''

     SCREAMING_SNAKE_CASE__: Dict=   '''
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
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   '''hf-internal-testing/tiny-random-bert'''
     BertConfig.from_pretrained(lowerCAmelCase )
     BertModel.from_pretrained(lowerCAmelCase )
     BertTokenizer.from_pretrained(lowerCAmelCase )
     pipeline(task='''fill-mask'''			,			model=lowerCAmelCase )

     # baseline - just load from_pretrained with normal network
     SCREAMING_SNAKE_CASE__: List[str]=   [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]

     # should succeed
     SCREAMING_SNAKE_CASE__: Any=   self.get_env()
     # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   '''1'''
     SCREAMING_SNAKE_CASE__: str=   subprocess.run(lowerCAmelCase			,			env=lowerCAmelCase			,			check=lowerCAmelCase			,			capture_output=lowerCAmelCase )
     self.assertEqual(result.returncode			,			0			,			result.stderr )
     self.assertIn('''success'''			,			result.stdout.decode() )
    @require_torch
    def     UpperCamelCase_					(	self )							->       str:
     # python one-liner segments
     # this must be loaded before socket.socket is monkey-patched
     SCREAMING_SNAKE_CASE__: Optional[Any]=   '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        '''

     SCREAMING_SNAKE_CASE__: Any=   '''
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")
        '''

     SCREAMING_SNAKE_CASE__: Optional[int]=   '''
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
     SCREAMING_SNAKE_CASE__: Optional[Any]=   '''hf-internal-testing/tiny-random-bert'''
     BertConfig.from_pretrained(lowerCAmelCase )
     BertModel.from_pretrained(lowerCAmelCase )
     BertTokenizer.from_pretrained(lowerCAmelCase )
     pipeline(task='''fill-mask'''			,			model=lowerCAmelCase )

     # baseline - just load from_pretrained with normal network
     SCREAMING_SNAKE_CASE__: Optional[int]=   [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]

     # should succeed
     SCREAMING_SNAKE_CASE__: Optional[int]=   self.get_env()
     SCREAMING_SNAKE_CASE__: Tuple=   subprocess.run(lowerCAmelCase			,			env=lowerCAmelCase			,			check=lowerCAmelCase			,			capture_output=lowerCAmelCase )
     self.assertEqual(result.returncode			,			0			,			result.stderr )
     self.assertIn('''success'''			,			result.stdout.decode() )
    @require_torch
    def     UpperCamelCase_					(	self )							->       Optional[Any]:
     # 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
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   '''
from transformers import BertConfig, BertModel, BertTokenizer
        '''

     SCREAMING_SNAKE_CASE__: Any=   '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
        '''

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

     # should succeed
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   self.get_env()
     SCREAMING_SNAKE_CASE__: Optional[int]=   subprocess.run(lowerCAmelCase			,			env=lowerCAmelCase			,			check=lowerCAmelCase			,			capture_output=lowerCAmelCase )
     self.assertEqual(result.returncode			,			0			,			result.stderr )
     self.assertIn('''success'''			,			result.stdout.decode() )

     # next emulate no network
     SCREAMING_SNAKE_CASE__: Tuple=   [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
     SCREAMING_SNAKE_CASE__: List[str]=   '''1'''
     SCREAMING_SNAKE_CASE__: Optional[int]=   subprocess.run(lowerCAmelCase			,			env=lowerCAmelCase			,			check=lowerCAmelCase			,			capture_output=lowerCAmelCase )
     self.assertEqual(result.returncode			,			0			,			result.stderr )
     self.assertIn('''success'''			,			result.stdout.decode() )
    @require_torch
    def     UpperCamelCase_					(	self )							->       List[Any]:
     SCREAMING_SNAKE_CASE__: Tuple=   '''
from transformers import pipeline
        '''
     SCREAMING_SNAKE_CASE__: Dict=   '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
        '''

     SCREAMING_SNAKE_CASE__: Optional[int]=   '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
        '''
     SCREAMING_SNAKE_CASE__: Any=   self.get_env()
     SCREAMING_SNAKE_CASE__: Optional[Any]=   '''1'''
     SCREAMING_SNAKE_CASE__: Any=   [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
     SCREAMING_SNAKE_CASE__: Tuple=   subprocess.run(lowerCAmelCase			,			env=lowerCAmelCase			,			check=lowerCAmelCase			,			capture_output=lowerCAmelCase )
     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 )							->       Union[str, Any]:
     SCREAMING_SNAKE_CASE__: str=   '''
from transformers import AutoModel
        '''
     SCREAMING_SNAKE_CASE__: Dict=   '''
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
     SCREAMING_SNAKE_CASE__: str=   [sys.executable, '''-c''', '''\n'''.join([load, run] )]

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



import pprint

import requests

lowerCamelCase__						=				"https://zenquotes.io/api"


def 				__A()		->					list:

		"""simple docstring"""






		return requests.get(API_ENDPOINT_URL + """/today"""			).json()


def 				__A()		->					list:

		"""simple docstring"""






		return requests.get(API_ENDPOINT_URL + """/random"""			).json()


if __name__ == "__main__":
		lowerCamelCase__						=				random_quotes()
		pprint.pprint(response)



