

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


A_						:     List[Any]			  =				namedtuple('ExampleNamedTuple', 'a b c')
class    A_				( unittest.TestCase  ):


    '''simple docstring'''






    def        lowerCAmelCase_  (self					)       -> int:
        __UpperCAmelCase			   =     torch.randn(5       , 2					)
        __UpperCAmelCase			   =     torch.device('''cuda'''					) if torch.cuda.is_available() else torch.device('''cpu'''					)

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

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

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

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

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

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

        __UpperCAmelCase			   =     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					)       -> Union[str, Any]:
        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					)       -> Dict:
        __UpperCAmelCase			   =     RegressionModel()
        __UpperCAmelCase			   =     model.forward
        __UpperCAmelCase			   =     convert_outputs_to_fpaa(model.forward					)
        __UpperCAmelCase			   =     extract_model_from_parallel(lowercase__       , keep_fpaa_wrapper=lowercase__					)
        __UpperCAmelCase			   =     pickle.dumps(lowercase__					)


    @require_cuda
    def        lowerCAmelCase_  (self					)       -> Any:
        __UpperCAmelCase			   =     RegressionModel()
        __UpperCAmelCase			   =     model.forward
        __UpperCAmelCase			   =     torch.cuda.amp.autocast(dtype=torch.floataa					)(model.forward					)
        __UpperCAmelCase			   =     convert_outputs_to_fpaa(model.forward					)
        __UpperCAmelCase			   =     extract_model_from_parallel(lowercase__       , keep_fpaa_wrapper=lowercase__					)
        __UpperCAmelCase			   =     pickle.dumps(lowercase__					)


    @require_cuda
    @require_torch_min_version(version='''2.0'''					)
    def        lowerCAmelCase_  (self					)       -> Union[str, Any]:
        __UpperCAmelCase			   =     RegressionModel()
        __UpperCAmelCase			   =     model.forward
        __UpperCAmelCase			   =     torch.cuda.amp.autocast(dtype=torch.floataa					)(model.forward					)
        __UpperCAmelCase			   =     convert_outputs_to_fpaa(model.forward					)
        __UpperCAmelCase			   =     torch.compile(model.forward       , backend='''inductor'''					)
        __UpperCAmelCase			   =     torch.randn(4       , 10					).cuda()
        __UpperCAmelCase			   =     model(lowercase__					)


    def        lowerCAmelCase_  (self					)       -> int:
        __UpperCAmelCase			   =     RegressionModel()
        # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
        __UpperCAmelCase			   =     torch.nn.parallel.DataParallel(lowercase__					)
        __UpperCAmelCase			   =     extract_model_from_parallel(lowercase__					)

        self.assertEqual(lowercase__       , lowercase__					)


    @require_torch_min_version(version='''2.0'''					)
    def        lowerCAmelCase_  (self					)       -> Tuple:
        __UpperCAmelCase			   =     RegressionModel()
        __UpperCAmelCase			   =     torch.compile(lowercase__					)

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

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






    def        lowerCAmelCase_  (self					)       -> Optional[Any]:
        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''']					)					)







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






    a__       							=    {
        "sld_warmup_steps": 15,
        "sld_guidance_scale": 20,
        "sld_threshold": 0.0,
        "sld_momentum_scale": 0.0,
        "sld_mom_beta": 0.0,
    }
    a__       							=    {
        "sld_warmup_steps": 10,
        "sld_guidance_scale": 10_00,
        "sld_threshold": 0.01,
        "sld_momentum_scale": 0.3,
        "sld_mom_beta": 0.4,
    }
    a__       							=    {
        "sld_warmup_steps": 7,
        "sld_guidance_scale": 20_00,
        "sld_threshold": 0.0_25,
        "sld_momentum_scale": 0.5,
        "sld_mom_beta": 0.7,
    }
    a__       							=    {
        "sld_warmup_steps": 0,
        "sld_guidance_scale": 50_00,
        "sld_threshold": 1.0,
        "sld_momentum_scale": 0.5,
        "sld_mom_beta": 0.7,
    }






@dataclass
class    A_				( _a  ):


    '''simple docstring'''






    a__       							=    42
    a__       							=    42
    a__       							=    42
    a__       							=    42


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




