import subprocess
import sys

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





class      A							(				UpperCAmelCase_     ):


   @require_torch
   def 			lowercase_      (self     :						List[Any]		)						->				Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

         UpperCAmelCase__								=  "\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        "

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

         # should succeed
         UpperCAmelCase__								=  self.get_env()
         # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
         UpperCAmelCase__								=  "1"
         UpperCAmelCase__								=  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 			lowercase_      (self     :						List[Any]		)						->				int:
         """simple docstring"""



         UpperCAmelCase__								=  "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

         UpperCAmelCase__								=  "\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        "

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

         # should succeed
         UpperCAmelCase__								=  self.get_env()
         UpperCAmelCase__								=  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 			lowercase_      (self     :						Optional[Any]		)						->				Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  "\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        "

         UpperCAmelCase__								=  "\nmname = \"hf-internal-testing/tiny-random-bert-sharded\"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint(\"success\")\n        "

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

         # should succeed
         UpperCAmelCase__								=  self.get_env()
         UpperCAmelCase__								=  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
         UpperCAmelCase__								=  [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
         UpperCAmelCase__								=  "1"
         UpperCAmelCase__								=  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 			lowercase_      (self     :						Dict		)						->				int:
         """simple docstring"""



         UpperCAmelCase__								=  "\nfrom transformers import pipeline\n        "
         UpperCAmelCase__								=  "\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n        "

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



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

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




import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment





class      A							(				unittest.TestCase     ):


   def 			lowercase_      (self     :						Union[str, Any]		)						->				str:
         """simple docstring"""



         UpperCAmelCase__								=  inspect.getfile(accelerate.test_utils		)
         UpperCAmelCase__								=  os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["scripts", "test_script.py"]		)
         UpperCAmelCase__								=  os.path.sep.join(
             mod_file.split(os.path.sep		)[:-1] + ["scripts", "test_distributed_data_loop.py"]		)
         UpperCAmelCase__								=  os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["scripts", "test_ops.py"]		)


   @require_multi_gpu
   def 			lowercase_      (self     :						List[str]		)						->				Any:
         """simple docstring"""



         print(f"""Found {torch.cuda.device_count()} devices."""		)
         UpperCAmelCase__								=  ["torchrun", f"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
         with patch_environment(omp_num_threads=1		):
               execute_subprocess_async(__UpperCAmelCase       ,  env=os.environ.copy()		)


   @require_multi_gpu
   def 			lowercase_      (self     :						str		)						->				str:
         """simple docstring"""



         print(f"""Found {torch.cuda.device_count()} devices."""		)
         UpperCAmelCase__								=  ["torchrun", f"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
         print(f"""Command: {cmd}"""		)
         with patch_environment(omp_num_threads=1		):
               execute_subprocess_async(__UpperCAmelCase       ,  env=os.environ.copy()		)


   @require_multi_gpu
   def 			lowercase_      (self     :						Tuple		)						->				int:
         """simple docstring"""



         UpperCAmelCase__								=  ["torchrun", f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__		)]
         with patch_environment(omp_num_threads=1		):
               execute_subprocess_async(__UpperCAmelCase       ,  env=os.environ.copy()		)





   @require_multi_gpu
   def 			lowercase_      (self     :						Dict		)						->				str:
         """simple docstring"""



         print(f"""Found {torch.cuda.device_count()} devices, using 2 devices only"""		)
         UpperCAmelCase__								=  ["torchrun", f"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
         with patch_environment(omp_num_threads=1       ,  cuda_visible_devices="0,1"		):
               execute_subprocess_async(__UpperCAmelCase       ,  env=os.environ.copy()		)


if __name__ == "__main__":
      UpperCamelCase__											=					Accelerator()
      UpperCamelCase__											=					(accelerator.state.process_index + 2, 1_0)
      UpperCamelCase__											=					torch.randint(0, 1_0, shape).to(accelerator.device)

      UpperCamelCase__											=					''

      UpperCamelCase__											=					accelerator.pad_across_processes(tensor)
      if tensora.shape[0] != accelerator.state.num_processes + 1:
            error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
      if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
            error_msg += "Tensors have different values."
      if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
            error_msg += "Padding was not done with the right value (0)."

      UpperCamelCase__											=					accelerator.pad_across_processes(tensor, pad_first=True)
      if tensora.shape[0] != accelerator.state.num_processes + 1:
            error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
      UpperCamelCase__											=					accelerator.state.num_processes - accelerator.state.process_index - 1
      if not torch.equal(tensora[index:], tensor):
            error_msg += "Tensors have different values."
      if not torch.all(tensora[:index] == 0):
            error_msg += "Padding was not done with the right value (0)."

      # Raise error at the end to make sure we don't stop at the first failure.
      if len(error_msg) > 0:
            raise ValueError(error_msg)



