


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


_UpperCAmelCase					:			Tuple				     =					namedtuple("""ExampleNamedTuple""", """a b c""")


class    a__					(			unittest.TestCase   ):







				"""simple docstring"""



				def        _snake_case	(self		):
										__lowerCAmelCase											=					torch.randn(5							,      2		)
										__lowerCAmelCase											=					torch.device('''cuda'''		) if torch.cuda.is_available() else torch.device('''cpu'''		)

										__lowerCAmelCase											=					send_to_device(__lowercase							,      __lowercase		)
										self.assertTrue(torch.equal(resulta.cpu()							,      __lowercase		)		)

										__lowerCAmelCase											=					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		)

										__lowerCAmelCase											=					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		)

										__lowerCAmelCase											=					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		)

										__lowerCAmelCase											=					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        _snake_case	(self		):
										with self.assertRaises(__lowercase		) as cm:
																__lowerCAmelCase											=					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        _snake_case	(self		):
										__lowerCAmelCase											=					torch.tensor([1, 2, 3, 4, 5]		)
										self.assertEqual(listify(__lowercase		)							,      [1, 2, 3, 4, 5]		)

										__lowerCAmelCase											=					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]]		)

										__lowerCAmelCase											=					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        _snake_case	(self		):
										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        _snake_case	(self		):
										__lowerCAmelCase											=					RegressionModel()
										__lowerCAmelCase											=					model.forward
										__lowerCAmelCase											=					convert_outputs_to_fpaa(model.forward		)
										__lowerCAmelCase											=					extract_model_from_parallel(__lowercase							,      keep_fpaa_wrapper=__lowercase		)
										__lowerCAmelCase											=					pickle.dumps(__lowercase		)




				@require_cuda
				def        _snake_case	(self		):
										__lowerCAmelCase											=					RegressionModel()
										__lowerCAmelCase											=					model.forward
										__lowerCAmelCase											=					torch.cuda.amp.autocast(dtype=torch.floataa		)(model.forward		)
										__lowerCAmelCase											=					convert_outputs_to_fpaa(model.forward		)
										__lowerCAmelCase											=					extract_model_from_parallel(__lowercase							,      keep_fpaa_wrapper=__lowercase		)
										__lowerCAmelCase											=					pickle.dumps(__lowercase		)




				@require_cuda
				@require_torch_min_version(version='''2.0'''		)
				def        _snake_case	(self		):
										__lowerCAmelCase											=					RegressionModel()
										__lowerCAmelCase											=					model.forward
										__lowerCAmelCase											=					torch.cuda.amp.autocast(dtype=torch.floataa		)(model.forward		)
										__lowerCAmelCase											=					convert_outputs_to_fpaa(model.forward		)
										__lowerCAmelCase											=					torch.compile(model.forward							,      backend='''inductor'''		)
										__lowerCAmelCase											=					torch.randn(4							,      10		).cuda()
										__lowerCAmelCase											=					model(__lowercase		)




				def        _snake_case	(self		):
										__lowerCAmelCase											=					RegressionModel()
										# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
										__lowerCAmelCase											=					torch.nn.parallel.DataParallel(__lowercase		)
										__lowerCAmelCase											=					extract_model_from_parallel(__lowercase		)

										self.assertEqual(__lowercase							,      __lowercase		)




				@require_torch_min_version(version='''2.0'''		)
				def        _snake_case	(self		):
										__lowerCAmelCase											=					RegressionModel()
										__lowerCAmelCase											=					torch.compile(__lowercase		)

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

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




				def        _snake_case	(self		):
										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 dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available


@dataclass
class    a__					(			__A   ):







				"""simple docstring"""



				__UpperCamelCase     :		Tuple						=						{
				    'sld_warmup_steps': 15,
				    'sld_guidance_scale': 20,
				    'sld_threshold': 0.0,
				    'sld_momentum_scale': 0.0,
				    'sld_mom_beta': 0.0,
				}
				__UpperCamelCase     :		Optional[Any]						=						{
				    'sld_warmup_steps': 10,
				    'sld_guidance_scale': 1_000,
				    'sld_threshold': 0.01,
				    'sld_momentum_scale': 0.3,
				    'sld_mom_beta': 0.4,
				}
				__UpperCamelCase     :		Tuple						=						{
				    'sld_warmup_steps': 7,
				    'sld_guidance_scale': 2_000,
				    'sld_threshold': 0.025,
				    'sld_momentum_scale': 0.5,
				    'sld_mom_beta': 0.7,
				}
				__UpperCamelCase     :		str						=						{
				    'sld_warmup_steps': 0,
				    'sld_guidance_scale': 5_000,
				    'sld_threshold': 1.0,
				    'sld_momentum_scale': 0.5,
				    'sld_mom_beta': 0.7,
				}


@dataclass
class    a__					(			__A   ):







				"""simple docstring"""



				__UpperCamelCase     :		Union[List[PIL.Image.Image], np.ndarray]
				__UpperCamelCase     :		Optional[List[bool]]
				__UpperCamelCase     :		Optional[Union[List[PIL.Image.Image], np.ndarray]]
				__UpperCamelCase     :		Optional[str]


if is_transformers_available() and is_torch_available():
	from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
	from .safety_checker import SafeStableDiffusionSafetyChecker

