

'''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,
)


_lowerCamelCase    =  namedtuple('ExampleNamedTuple', 'a b c')
class 					__a   (		unittest.TestCase  ):

						def 	_UpperCAmelCase							(		self	:						Optional[int])						->int:

							"""simple docstring"""



							_lowercase							=     torch.randn(5    ,			2)
							_lowercase							=     torch.device("""cuda""") if torch.cuda.is_available() else torch.device("""cpu""")

							_lowercase							=     send_to_device(__UpperCAmelCase    ,			__UpperCAmelCase)
							self.assertTrue(torch.equal(resulta.cpu()    ,			__UpperCAmelCase))

							_lowercase							=     send_to_device((tensor, [tensor, tensor], 1)    ,			__UpperCAmelCase)
							self.assertIsInstance(__UpperCAmelCase    ,			__UpperCAmelCase)
							self.assertTrue(torch.equal(resulta[0].cpu()    ,			__UpperCAmelCase))
							self.assertIsInstance(resulta[1]    ,			__UpperCAmelCase)
							self.assertTrue(torch.equal(resulta[1][0].cpu()    ,			__UpperCAmelCase))
							self.assertTrue(torch.equal(resulta[1][1].cpu()    ,			__UpperCAmelCase))
							self.assertEqual(resulta[2]    ,			1)

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

							_lowercase							=     send_to_device(ExampleNamedTuple(a=__UpperCAmelCase    ,			b=[tensor, tensor]    ,			c=1)    ,			__UpperCAmelCase)
							self.assertIsInstance(__UpperCAmelCase    ,			__UpperCAmelCase)
							self.assertTrue(torch.equal(resulta.a.cpu()    ,			__UpperCAmelCase))
							self.assertIsInstance(resulta.b    ,			__UpperCAmelCase)
							self.assertTrue(torch.equal(resulta.b[0].cpu()    ,			__UpperCAmelCase))
							self.assertTrue(torch.equal(resulta.b[1].cpu()    ,			__UpperCAmelCase))
							self.assertEqual(resulta.c    ,			1)

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

						def 	_UpperCAmelCase							(		self	:						Optional[int])						->Any:

							"""simple docstring"""



							with self.assertRaises(__UpperCAmelCase) as cm:
								_lowercase							=     recursively_apply(torch.tensor    ,			(torch.tensor(1), 1)    ,			error_on_other_type=__UpperCAmelCase)
							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 	_UpperCAmelCase							(		self	:						List[Any])						->Any:

							"""simple docstring"""



							_lowercase							=     torch.tensor([1, 2, 3, 4, 5])
							self.assertEqual(listify(__UpperCAmelCase)    ,			[1, 2, 3, 4, 5])

							_lowercase							=     torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
							self.assertEqual(listify(__UpperCAmelCase)    ,			[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

							_lowercase							=     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(__UpperCAmelCase)    ,			[[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]])

						def 	_UpperCAmelCase							(		self	:						Tuple)						->str:

							"""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 	_UpperCAmelCase							(		self	:						Tuple)						->Tuple:

							"""simple docstring"""



							_lowercase							=     RegressionModel()
							_lowercase							=     model.forward
							_lowercase							=     convert_outputs_to_fpaa(model.forward)
							_lowercase							=     extract_model_from_parallel(__UpperCAmelCase    ,			keep_fpaa_wrapper=__UpperCAmelCase)
							_lowercase							=     pickle.dumps(__UpperCAmelCase)

						@require_cuda
						def 	_UpperCAmelCase							(		self	:						str)						->List[Any]:

							"""simple docstring"""



							_lowercase							=     RegressionModel()
							_lowercase							=     model.forward
							_lowercase							=     torch.cuda.amp.autocast(dtype=torch.floataa)(model.forward)
							_lowercase							=     convert_outputs_to_fpaa(model.forward)
							_lowercase							=     extract_model_from_parallel(__UpperCAmelCase    ,			keep_fpaa_wrapper=__UpperCAmelCase)
							_lowercase							=     pickle.dumps(__UpperCAmelCase)

						@require_cuda
						@require_torch_min_version(version="""2.0""")
						def 	_UpperCAmelCase							(		self	:						List[str])						->str:

							"""simple docstring"""



							_lowercase							=     RegressionModel()
							_lowercase							=     model.forward
							_lowercase							=     torch.cuda.amp.autocast(dtype=torch.floataa)(model.forward)
							_lowercase							=     convert_outputs_to_fpaa(model.forward)
							_lowercase							=     torch.compile(model.forward    ,			backend="""inductor""")
							_lowercase							=     torch.randn(4    ,			10).cuda()
							_lowercase							=     model(__UpperCAmelCase)

						def 	_UpperCAmelCase							(		self	:						Optional[Any])						->Union[str, Any]:

							"""simple docstring"""



							_lowercase							=     RegressionModel()
							# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
							_lowercase							=     torch.nn.parallel.DataParallel(__UpperCAmelCase)
							_lowercase							=     extract_model_from_parallel(__UpperCAmelCase)

							self.assertEqual(__UpperCAmelCase    ,			__UpperCAmelCase)

						@require_torch_min_version(version="""2.0""")
						def 	_UpperCAmelCase							(		self	:						Dict)						->Optional[Any]:

							"""simple docstring"""



							_lowercase							=     RegressionModel()
							_lowercase							=     torch.compile(__UpperCAmelCase)

							# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
							_lowercase							=     torch.nn.parallel.DataParallel(__UpperCAmelCase)
							_lowercase							=     torch.compile(__UpperCAmelCase)
							_lowercase							=     extract_model_from_parallel(__UpperCAmelCase)

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


						def 	_UpperCAmelCase							(		self	:						List[Any])						->List[Any]:

							"""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 collections import namedtuple

UpperCamelCase_						   =   namedtuple('from_to', 'from_ to')

UpperCamelCase_						   =   {
    'atm': from_to(1, 1),
    'pascal': from_to(0.0_00_00_98, 101325),
    'bar': from_to(0.98_69_23, 1.0_13_25),
    'kilopascal': from_to(0.00_98_69_23, 1_01.3_25),
    'megapascal': from_to(9.8_69_23, 0.10_13_25),
    'psi': from_to(0.06_80_46, 14.69_59),
    'inHg': from_to(0.0_33_42_11, 29.92_13),
    'torr': from_to(0.00_13_15_79, 760),
}
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase     )						->float:

   """simple docstring"""



   if from_type not in PRESSURE_CONVERSION:
      raise ValueError(
          F'''Invalid \'from_type\' value: {from_type!r}  Supported values are:\n'''
          + ", ".join(UpperCAmelCase     )     )
   if to_type not in PRESSURE_CONVERSION:
      raise ValueError(
          F'''Invalid \'to_type\' value: {to_type!r}.  Supported values are:\n'''
          + ", ".join(UpperCAmelCase     )     )
   return (
       value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()