

'''simple docstring'''






import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


snake_case_       =       namedtuple('ExampleNamedTuple', 'a b c')
class 	SCREAMING_SNAKE_CASE__			(				unittest.TestCase      ):




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       torch.randn(5				,     2			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       torch.device("cuda"			) if torch.cuda.is_available() else torch.device("cpu"			)

          SCREAMING_SNAKE_CASE_      :			Dict     =       send_to_device(lowercase__				,     lowercase__			)
          self.assertTrue(torch.equal(resulta.cpu()				,     lowercase__			)			)

          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       send_to_device((tensor, [tensor, tensor], 1)				,     lowercase__			)
          self.assertIsInstance(lowercase__				,     lowercase__			)
          self.assertTrue(torch.equal(resulta[0].cpu()				,     lowercase__			)			)
          self.assertIsInstance(resulta[1]				,     lowercase__			)
          self.assertTrue(torch.equal(resulta[1][0].cpu()				,     lowercase__			)			)
          self.assertTrue(torch.equal(resulta[1][1].cpu()				,     lowercase__			)			)
          self.assertEqual(resulta[2]				,     1			)

          SCREAMING_SNAKE_CASE_      :			Any     =       send_to_device({"a": tensor, "b": [tensor, tensor], "c": 1}				,     lowercase__			)
          self.assertIsInstance(lowercase__				,     lowercase__			)
          self.assertTrue(torch.equal(resulta["a"].cpu()				,     lowercase__			)			)
          self.assertIsInstance(resulta["b"]				,     lowercase__			)
          self.assertTrue(torch.equal(resulta["b"][0].cpu()				,     lowercase__			)			)
          self.assertTrue(torch.equal(resulta["b"][1].cpu()				,     lowercase__			)			)
          self.assertEqual(resulta["c"]				,     1			)

          SCREAMING_SNAKE_CASE_      :			List[str]     =       send_to_device(ExampleNamedTuple(a=lowercase__				,     b=[tensor, tensor]				,     c=1			)				,     lowercase__			)
          self.assertIsInstance(lowercase__				,     lowercase__			)
          self.assertTrue(torch.equal(resulta.a.cpu()				,     lowercase__			)			)
          self.assertIsInstance(resulta.b				,     lowercase__			)
          self.assertTrue(torch.equal(resulta.b[0].cpu()				,     lowercase__			)			)
          self.assertTrue(torch.equal(resulta.b[1].cpu()				,     lowercase__			)			)
          self.assertEqual(resulta.c				,     1			)

          SCREAMING_SNAKE_CASE_      :			Dict     =       send_to_device(UserDict({"a": tensor, "b": [tensor, tensor], "c": 1}			)				,     lowercase__			)
          self.assertIsInstance(lowercase__				,     lowercase__			)
          self.assertTrue(torch.equal(resulta["a"].cpu()				,     lowercase__			)			)
          self.assertIsInstance(resulta["b"]				,     lowercase__			)
          self.assertTrue(torch.equal(resulta["b"][0].cpu()				,     lowercase__			)			)
          self.assertTrue(torch.equal(resulta["b"][1].cpu()				,     lowercase__			)			)
          self.assertEqual(resulta["c"]				,     1			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          with self.assertRaises(lowercase__			) as cm:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       recursively_apply(torch.tensor				,     (torch.tensor(1			), 1)				,     error_on_other_type=lowercase__			)
          self.assertEqual(
              str(cm.exception			)				,     "Unsupported types (<class 'int'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed."				,     )




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       torch.tensor([1, 2, 3, 4, 5]			)
          self.assertEqual(listify(lowercase__			)				,     [1, 2, 3, 4, 5]			)

          SCREAMING_SNAKE_CASE_      :			Dict     =       torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]			)
          self.assertEqual(listify(lowercase__			)				,     [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]			)

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]			)
          self.assertEqual(
              listify(lowercase__			)				,     [[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          with patch_environment(aa=1				,     BB=2			):
                self.assertEqual(os.environ.get("AA"			)				,     "1"			)
                self.assertEqual(os.environ.get("BB"			)				,     "2"			)

          self.assertNotIn("AA"				,     os.environ			)
          self.assertNotIn("BB"				,     os.environ			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       RegressionModel()
          SCREAMING_SNAKE_CASE_      :			Dict     =       model.forward
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       convert_outputs_to_fpaa(model.forward			)
          SCREAMING_SNAKE_CASE_      :			str     =       extract_model_from_parallel(lowercase__				,     keep_fpaa_wrapper=lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       pickle.dumps(lowercase__			)




    @require_cuda
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       RegressionModel()
          SCREAMING_SNAKE_CASE_      :			List[str]     =       model.forward
          SCREAMING_SNAKE_CASE_      :			int     =       torch.cuda.amp.autocast(dtype=torch.floataa			)(model.forward			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       convert_outputs_to_fpaa(model.forward			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       extract_model_from_parallel(lowercase__				,     keep_fpaa_wrapper=lowercase__			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       pickle.dumps(lowercase__			)




    @require_cuda
    @require_torch_min_version(version="2.0"			)
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       RegressionModel()
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       model.forward
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       torch.cuda.amp.autocast(dtype=torch.floataa			)(model.forward			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       convert_outputs_to_fpaa(model.forward			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       torch.compile(model.forward				,     backend="inductor"			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       torch.randn(4				,     10			).cuda()
          SCREAMING_SNAKE_CASE_      :			int     =       model(lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       RegressionModel()
          # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
          SCREAMING_SNAKE_CASE_      :			Dict     =       torch.nn.parallel.DataParallel(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       extract_model_from_parallel(lowercase__			)

          self.assertEqual(lowercase__				,     lowercase__			)




    @require_torch_min_version(version="2.0"			)
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       RegressionModel()
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       torch.compile(lowercase__			)

          # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
          SCREAMING_SNAKE_CASE_      :			Tuple     =       torch.nn.parallel.DataParallel(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			str     =       torch.compile(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       extract_model_from_parallel(lowercase__			)

          self.assertEqual(compiled_model._orig_mod				,     compiled_model_unwrapped._orig_mod			)







    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          self.assertEqual(find_device([1, "a", torch.tensor([1, 2, 3]			)]			)				,     torch.device("cpu"			)			)
          self.assertEqual(find_device({"a": 1, "b": torch.tensor([1, 2, 3]			)}			)				,     torch.device("cpu"			)			)
          self.assertIsNone(find_device([1, "a"]			)			)




'''simple docstring'''






from ..utils import DummyObject, requires_backends
class 	SCREAMING_SNAKE_CASE__			(				metaclass=_UpperCAmelCase      ):
    _A			    =							["torch", "transformers", "invisible_watermark"]




    def __init__(					self				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(self				,     ["torch", "transformers", "invisible_watermark"]			)




    @classmethod
    def   __lowerCamelCase      (					cls				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(cls				,     ["torch", "transformers", "invisible_watermark"]			)







    @classmethod
    def   __lowerCamelCase      (					cls				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(cls				,     ["torch", "transformers", "invisible_watermark"]			)






class 	SCREAMING_SNAKE_CASE__			(				metaclass=_UpperCAmelCase      ):
    _A			    =							["torch", "transformers", "invisible_watermark"]




    def __init__(					self				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(self				,     ["torch", "transformers", "invisible_watermark"]			)




    @classmethod
    def   __lowerCamelCase      (					cls				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(cls				,     ["torch", "transformers", "invisible_watermark"]			)







    @classmethod
    def   __lowerCamelCase      (					cls				,     *lowercase__				,     **lowercase__			):






          """simple docstring"""






          requires_backends(cls				,     ["torch", "transformers", "invisible_watermark"]			)

