"""simple docstring"""






import subprocess
import sys

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





class  _A						(       lowerCAmelCase	):

      @require_torch
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	"""
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

            lowercase														=	"""
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\")
        """

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

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







            """simple docstring"""



            lowercase														=	"""
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

            lowercase														=	"""
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\")
        """

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

            # should succeed
            lowercase														=	self.get_env()
            lowercase														=	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 				A__       (						self						):







            """simple docstring"""



            lowercase														=	"""
from transformers import BertConfig, BertModel, BertTokenizer
        """

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

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

            # should succeed
            lowercase														=	self.get_env()
            lowercase														=	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
            lowercase														=	[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
            lowercase														=	"""1"""
            lowercase														=	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 				A__       (						self						):







            """simple docstring"""



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

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







            """simple docstring"""



            lowercase														=	"""
from transformers import AutoModel
        """
            lowercase														=	"""
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
            lowercase														=	[sys.executable, """-c""", """\n""".join([load, run]						)]

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




"""simple docstring"""






from __future__ import annotations

import numpy as np


def 			UpperCAmelCase__       (				lowerCAmelCase__     :list[float]		) ->    Optional[Any]:
      '''simple docstring'''


      return np.maximum(0					,		lowerCAmelCase__		)


if __name__ == "__main__":
       print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]



