






"""simple docstring"""







import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
			import jax
			import jax.numpy as jnp

			from transformers.modeling_flax_pytorch_utils import (
			    convert_pytorch_state_dict_to_flax,
			    load_flax_weights_in_pytorch_model,
			)
			from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
			import torch


class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__=14       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=False       ,  snake_case__=True       ,  snake_case__=99       ,  snake_case__=32       ,  snake_case__=5       ,  snake_case__=4       ,  snake_case__=37       ,  snake_case__="gelu"       ,  snake_case__=0.1       ,  snake_case__=0.1       ,  snake_case__=512       ,  snake_case__=0.02       ,  ):
												'''simple docstring'''
												lowercase__				:      Tuple=       parent
												lowercase__				:      Union[str, Any]=       batch_size
												lowercase__				:      Any=       seq_length
												lowercase__				:      Tuple=       is_training
												lowercase__				:      Union[str, Any]=       use_input_mask
												lowercase__				:      int=       use_token_type_ids
												lowercase__				:      int=       use_labels
												lowercase__				:      Union[str, Any]=       vocab_size
												lowercase__				:      Tuple=       hidden_size
												lowercase__				:      List[str]=       num_hidden_layers
												lowercase__				:      Tuple=       num_attention_heads
												lowercase__				:      Any=       intermediate_size
												lowercase__				:      str=       hidden_act
												lowercase__				:      int=       hidden_dropout_prob
												lowercase__				:      Optional[Any]=       attention_probs_dropout_prob
												lowercase__				:      List[str]=       max_position_embeddings
												lowercase__				:      List[str]=       initializer_range
												lowercase__				:      int=       None
												lowercase__				:      int=       vocab_size - 1
												lowercase__				:      Any=       vocab_size - 1
												lowercase__				:      List[str]=       vocab_size - 1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size			)

												lowercase__				:      List[str]=       None
												if self.use_input_mask:
																		lowercase__				:      Optional[Any]=       random_attention_mask([self.batch_size, self.seq_length]			)

												lowercase__				:      Optional[Any]=       GPTaConfig(
												    vocab_size=self.vocab_size       ,  n_embd=self.hidden_size       ,  n_layer=self.num_hidden_layers       ,  n_head=self.num_attention_heads       ,  n_positions=self.max_position_embeddings       ,  use_cache=snake_case__       ,  bos_token_id=self.bos_token_id       ,  eos_token_id=self.eos_token_id       ,  pad_token_id=self.pad_token_id       ,  )

												return (config, input_ids, input_mask)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[str]=       self.prepare_config_and_inputs()
												lowercase__,	lowercase__,	lowercase__				:      Dict=       config_and_inputs
												lowercase__				:      Optional[int]=       {"input_ids": input_ids, "attention_mask": attention_mask}
												return config, inputs_dict




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__,	lowercase__,	lowercase__				:      Dict=       self.prepare_config_and_inputs()

												lowercase__				:      Optional[Any]=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
												lowercase__				:      Optional[Any]=       ids_tensor([self.batch_size, self.seq_length]       ,  vocab_size=2			)

												return (
												    config,
												    input_ids,
												    attention_mask,
												    encoder_hidden_states,
												    encoder_attention_mask,
												)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      Any=       20
												lowercase__				:      Dict=       model_class_name(snake_case__			)

												lowercase__				:      Dict=       model.init_cache(input_ids.shape[0]       ,  snake_case__			)
												lowercase__				:      List[Any]=       jnp.ones((input_ids.shape[0], max_decoder_length)       ,  dtype="i4"			)

												lowercase__				:      Optional[int]=       jnp.broadcast_to(
												    jnp.arange(input_ids.shape[-1] - 1			)[None, :]       ,  (input_ids.shape[0], input_ids.shape[-1] - 1)			)
												lowercase__				:      int=       model(
												    input_ids[:, :-1]       ,  attention_mask=snake_case__       ,  past_key_values=snake_case__       ,  position_ids=snake_case__       ,  )

												lowercase__				:      Any=       jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]       ,  dtype="i4"			)
												lowercase__				:      Optional[Any]=       model(
												    input_ids[:, -1:]       ,  attention_mask=snake_case__       ,  past_key_values=outputs_cache.past_key_values       ,  position_ids=snake_case__       ,  )

												lowercase__				:      int=       model(snake_case__			)

												lowercase__				:      Dict=       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
												self.parent.assertTrue(diff < 1e-3       ,  msg=F'''Max diff is {diff}'''			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      List[str]=       20
												lowercase__				:      Tuple=       model_class_name(snake_case__			)

												lowercase__				:      str=       jnp.concatenate(
												    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])			)]       ,  axis=-1       ,  )

												lowercase__				:      str=       model.init_cache(input_ids.shape[0]       ,  snake_case__			)
												lowercase__				:      List[str]=       jnp.broadcast_to(
												    jnp.arange(input_ids.shape[-1] - 1			)[None, :]       ,  (input_ids.shape[0], input_ids.shape[-1] - 1)			)

												lowercase__				:      Optional[int]=       model(
												    input_ids[:, :-1]       ,  attention_mask=snake_case__       ,  past_key_values=snake_case__       ,  position_ids=snake_case__       ,  )
												lowercase__				:      Optional[int]=       jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]       ,  dtype="i4"			)
												lowercase__				:      str=       model(
												    input_ids[:, -1:]       ,  past_key_values=outputs_cache.past_key_values       ,  attention_mask=snake_case__       ,  position_ids=snake_case__       ,  )

												lowercase__				:      Union[str, Any]=       model(snake_case__       ,  attention_mask=snake_case__			)

												lowercase__				:      str=       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
												self.parent.assertTrue(diff < 1e-3       ,  msg=F'''Max diff is {diff}'''			)


@require_flax
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
						__lowerCamelCase				       =					(FlaxGPTaLMHeadModel,) if is_flax_available() else ()




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       FlaxGPTaModelTester(self			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												for model_class_name in self.all_model_classes:
																		lowercase__,	lowercase__,	lowercase__				:      int=       self.model_tester.prepare_config_and_inputs()
																		self.model_tester.check_use_cache_forward(snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												for model_class_name in self.all_model_classes:
																		lowercase__,	lowercase__,	lowercase__				:      Optional[int]=       self.model_tester.prepare_config_and_inputs()
																		self.model_tester.check_use_cache_forward_with_attn_mask(
																		    snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Dict=       GPTaTokenizer.from_pretrained("gpt2"       ,  pad_token="</s>"       ,  padding_side="left"			)
												lowercase__				:      List[str]=       tokenizer(["Hello this is a long string", "Hey"]       ,  return_tensors="np"       ,  padding=snake_case__       ,  truncation=snake_case__			)

												lowercase__				:      Union[str, Any]=       FlaxGPTaLMHeadModel.from_pretrained("gpt2"			)
												lowercase__				:      int=       False
												lowercase__				:      Tuple=       model.config.eos_token_id

												lowercase__				:      Tuple=       jax.jit(model.generate			)

												lowercase__				:      List[Any]=       jit_generate(inputs["input_ids"]       ,  attention_mask=inputs["attention_mask"]			).sequences

												lowercase__				:      List[str]=       tokenizer.batch_decode(snake_case__       ,  skip_special_tokens=snake_case__			)

												lowercase__				:      Optional[int]=       [
												    "Hello this is a long string of words. I'm going to start with the first one.\n",
												    "Hey, I'm not sure if I'm going to be able to do",
												]

												self.assertListEqual(snake_case__       ,  snake_case__			)




						@is_pt_flax_cross_test
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__,	lowercase__				:      Tuple=       self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__			):
																								# prepare inputs
																								lowercase__				:      Dict=       self._prepare_for_class(snake_case__       ,  snake_case__			)
																								lowercase__				:      Tuple=       {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

																								# load corresponding PyTorch class
																								lowercase__				:      Union[str, Any]=       model_class.__name__[4:]  # Skip the "Flax" at the beginning
																								lowercase__				:      Optional[int]=       getattr(snake_case__       ,  snake_case__			)

																								lowercase__,	lowercase__				:      List[Any]=       pt_inputs["input_ids"].shape
																								lowercase__				:      Optional[Any]=       np.random.randint(0       ,  seq_length - 1       ,  size=(batch_size,)			)
																								for batch_idx, start_index in enumerate(snake_case__			):
																														lowercase__				:      Tuple=       0
																														lowercase__				:      str=       1
																														lowercase__				:      Union[str, Any]=       0
																														lowercase__				:      Tuple=       1
																								lowercase__				:      Optional[int]=       pt_model_class(snake_case__			).eval()
																								lowercase__				:      Union[str, Any]=       model_class(snake_case__       ,  dtype=jnp.floataa			)

																								lowercase__				:      List[Any]=       convert_pytorch_state_dict_to_flax(pt_model.state_dict()       ,  snake_case__			)
																								lowercase__				:      Tuple=       fx_state

																								with torch.no_grad():
																														lowercase__				:      Optional[Any]=       pt_model(**snake_case__			).to_tuple()

																								lowercase__				:      int=       fx_model(**snake_case__			).to_tuple()
																								self.assertEqual(len(snake_case__			)       ,  len(snake_case__			)       ,  "Output lengths differ between Flax and PyTorch"			)
																								for fx_output, pt_output in zip(snake_case__       ,  snake_case__			):
																														self.assert_almost_equals(fx_output[:, -1]       ,  pt_output[:, -1].numpy()       ,  4e-2			)

																								with tempfile.TemporaryDirectory() as tmpdirname:
																														pt_model.save_pretrained(snake_case__			)
																														lowercase__				:      int=       model_class.from_pretrained(snake_case__       ,  from_pt=snake_case__			)

																								lowercase__				:      Union[str, Any]=       fx_model_loaded(**snake_case__			).to_tuple()
																								self.assertEqual(
																								    len(snake_case__			)       ,  len(snake_case__			)       ,  "Output lengths differ between Flax and PyTorch"			)
																								for fx_output_loaded, pt_output in zip(snake_case__       ,  snake_case__			):
																														self.assert_almost_equals(fx_output_loaded[:, -1]       ,  pt_output[:, -1].numpy()       ,  4e-2			)




						@is_pt_flax_cross_test
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__,	lowercase__				:      Any=       self.model_tester.prepare_config_and_inputs_for_common()
												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__			):
																								# prepare inputs
																								lowercase__				:      Any=       self._prepare_for_class(snake_case__       ,  snake_case__			)
																								lowercase__				:      Optional[Any]=       {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

																								# load corresponding PyTorch class
																								lowercase__				:      List[Any]=       model_class.__name__[4:]  # Skip the "Flax" at the beginning
																								lowercase__				:      Tuple=       getattr(snake_case__       ,  snake_case__			)

																								lowercase__				:      List[Any]=       pt_model_class(snake_case__			).eval()
																								lowercase__				:      int=       model_class(snake_case__       ,  dtype=jnp.floataa			)

																								lowercase__				:      str=       load_flax_weights_in_pytorch_model(snake_case__       ,  fx_model.params			)
																								lowercase__,	lowercase__				:      Dict=       pt_inputs["input_ids"].shape
																								lowercase__				:      int=       np.random.randint(0       ,  seq_length - 1       ,  size=(batch_size,)			)
																								for batch_idx, start_index in enumerate(snake_case__			):
																														lowercase__				:      Optional[int]=       0
																														lowercase__				:      Any=       1
																														lowercase__				:      List[str]=       0
																														lowercase__				:      Optional[int]=       1

																								# make sure weights are tied in PyTorch
																								pt_model.tie_weights()

																								with torch.no_grad():
																														lowercase__				:      Dict=       pt_model(**snake_case__			).to_tuple()

																								lowercase__				:      Any=       fx_model(**snake_case__			).to_tuple()
																								self.assertEqual(len(snake_case__			)       ,  len(snake_case__			)       ,  "Output lengths differ between Flax and PyTorch"			)
																								for fx_output, pt_output in zip(snake_case__       ,  snake_case__			):
																														self.assert_almost_equals(fx_output[:, -1]       ,  pt_output[:, -1].numpy()       ,  4e-2			)

																								with tempfile.TemporaryDirectory() as tmpdirname:
																														fx_model.save_pretrained(snake_case__			)
																														lowercase__				:      Tuple=       pt_model_class.from_pretrained(snake_case__       ,  from_flax=snake_case__			)

																								with torch.no_grad():
																														lowercase__				:      Optional[Any]=       pt_model_loaded(**snake_case__			).to_tuple()

																								self.assertEqual(
																								    len(snake_case__			)       ,  len(snake_case__			)       ,  "Output lengths differ between Flax and PyTorch"			)
																								for fx_output, pt_output in zip(snake_case__       ,  snake_case__			):
																														self.assert_almost_equals(fx_output[:, -1]       ,  pt_output[:, -1].numpy()       ,  4e-2			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												for model_class_name in self.all_model_classes:
																		lowercase__				:      str=       model_class_name.from_pretrained("gpt2"       ,  from_pt=snake_case__			)
																		lowercase__				:      List[str]=       model(np.ones((1, 1)			)			)
																		self.assertIsNotNone(snake_case__			)







'''simple docstring'''




import tempfile
import unittest

from diffusers import (
    DDIMScheduler,
    DDPMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    PNDMScheduler,
    logging,
)
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils.testing_utils import CaptureLogger




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					str    =				'config.json'

       @register_to_config
       def __init__(      self    ,     _SCREAMING_SNAKE_CASE=2    ,     _SCREAMING_SNAKE_CASE=5    ,     _SCREAMING_SNAKE_CASE=(2, 5)    ,     _SCREAMING_SNAKE_CASE="for diffusion"    ,     _SCREAMING_SNAKE_CASE=[1, 3]    ,     )		->     Union[str, Any]:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					Tuple    =				'config.json'

       @register_to_config
       def __init__(      self    ,     _SCREAMING_SNAKE_CASE=2    ,     _SCREAMING_SNAKE_CASE=5    ,     _SCREAMING_SNAKE_CASE=(2, 5)    ,     _SCREAMING_SNAKE_CASE="for diffusion"    ,     _SCREAMING_SNAKE_CASE=[1, 3]    ,     )		->     Union[str, Any]:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					Optional[Any]    =				'config.json'

       @register_to_config
       def __init__(      self    ,     _SCREAMING_SNAKE_CASE=2    ,     _SCREAMING_SNAKE_CASE=5    ,     _SCREAMING_SNAKE_CASE=(2, 5)    ,     _SCREAMING_SNAKE_CASE="for diffusion"    ,     _SCREAMING_SNAKE_CASE=[1, 3]    ,     _SCREAMING_SNAKE_CASE=[1, 3]    ,     )		->     Dict:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					Optional[Any]    =				'config.json'

       @register_to_config
       def __init__(      self    ,     _SCREAMING_SNAKE_CASE=2    ,     _SCREAMING_SNAKE_CASE=5    ,     _SCREAMING_SNAKE_CASE=(2, 5)    ,     _SCREAMING_SNAKE_CASE="for diffusion"    ,     _SCREAMING_SNAKE_CASE=[1, 5]    ,     _SCREAMING_SNAKE_CASE=[5, 4]    ,     )		->     List[str]:
           pass




class 	__UpperCAmelCase				(				unittest.TestCase     ):





       '''simple docstring'''



       def 					__A       (      self )		->     Optional[int]:
           with self.assertRaises(_SCREAMING_SNAKE_CASE ):
               ConfigMixin.load_config('''dummy_path''' )

       def 					__A       (      self )		->     Union[str, Any]:
           A_     =   SampleObject()
           A_     =   obj.config
           assert config["a"] == 2
           assert config["b"] == 5
           assert config["c"] == (2, 5)
           assert config["d"] == "for diffusion"
           assert config["e"] == [1, 3]

           # init ignore private arguments
           A_     =   SampleObject(_name_or_path='''lalala''' )
           A_     =   obj.config
           assert config["a"] == 2
           assert config["b"] == 5
           assert config["c"] == (2, 5)
           assert config["d"] == "for diffusion"
           assert config["e"] == [1, 3]

           # can override default
           A_     =   SampleObject(c=6 )
           A_     =   obj.config
           assert config["a"] == 2
           assert config["b"] == 5
           assert config["c"] == 6
           assert config["d"] == "for diffusion"
           assert config["e"] == [1, 3]

           # can use positional arguments.
           A_     =   SampleObject(1    ,     c=6 )
           A_     =   obj.config
           assert config["a"] == 1
           assert config["b"] == 5
           assert config["c"] == 6
           assert config["d"] == "for diffusion"
           assert config["e"] == [1, 3]

       def 					__A       (      self )		->     int:
           A_     =   SampleObject()
           A_     =   obj.config

           assert config["a"] == 2
           assert config["b"] == 5
           assert config["c"] == (2, 5)
           assert config["d"] == "for diffusion"
           assert config["e"] == [1, 3]

           with tempfile.TemporaryDirectory() as tmpdirname:
               obj.save_config(_SCREAMING_SNAKE_CASE )
               A_     =   SampleObject.from_config(SampleObject.load_config(_SCREAMING_SNAKE_CASE ) )
               A_     =   new_obj.config

           # unfreeze configs
           A_     =   dict(_SCREAMING_SNAKE_CASE )
           A_     =   dict(_SCREAMING_SNAKE_CASE )

           assert config.pop('''c''' ) == (2, 5)  # instantiated as tuple
           assert new_config.pop('''c''' ) == [2, 5]  # saved & loaded as list because of json
           config.pop('''_use_default_values''' )
           assert config == new_config

       def 					__A       (      self )		->     List[Any]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   DDIMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler''' )

           assert ddim.__class__ == DDIMScheduler
           # no warning should be thrown
           assert cap_logger.out == ""

       def 					__A       (      self )		->     List[str]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   EulerDiscreteScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler''' )

           assert euler.__class__ == EulerDiscreteScheduler
           # no warning should be thrown
           assert cap_logger.out == ""

       def 					__A       (      self )		->     Optional[Any]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   EulerAncestralDiscreteScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler''' )

           assert euler.__class__ == EulerAncestralDiscreteScheduler
           # no warning should be thrown
           assert cap_logger.out == ""

       def 					__A       (      self )		->     Optional[int]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   PNDMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler''' )

           assert pndm.__class__ == PNDMScheduler
           # no warning should be thrown
           assert cap_logger.out == ""

       def 					__A       (      self )		->     Tuple:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   DDPMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler'''    ,     prediction_type='''sample'''    ,     beta_end=8    ,     )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger_a:
               A_     =   DDPMScheduler.from_pretrained('''google/ddpm-celebahq-256'''    ,     beta_start=88 )

           assert ddpm.__class__ == DDPMScheduler
           assert ddpm.config.prediction_type == "sample"
           assert ddpm.config.beta_end == 8
           assert ddpm_a.config.beta_start == 88

           # no warning should be thrown
           assert cap_logger.out == ""
           assert cap_logger_a.out == ""

       def 					__A       (      self )		->     List[Any]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   DPMSolverMultistepScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''    ,     subfolder='''scheduler''' )

           assert dpm.__class__ == DPMSolverMultistepScheduler
           # no warning should be thrown
           assert cap_logger.out == ""

       def 					__A       (      self )		->     Optional[int]:
           # let's first save a config that should be in the form
           #    a=2,
           #    b=5,
           #    c=(2, 5),
           #    d="for diffusion",
           #    e=[1, 3],

           A_     =   SampleObject()

           A_     =   {k: v for k, v in config.config.items() if not k.startswith('''_''' )}

           # make sure that default config has all keys in `_use_default_values`
           assert set(config_dict.keys() ) == set(config.config._use_default_values )

           with tempfile.TemporaryDirectory() as tmpdirname:
               config.save_config(_SCREAMING_SNAKE_CASE )

               # now loading it with SampleObject2 should put f into `_use_default_values`
               A_     =   SampleObjecta.from_config(_SCREAMING_SNAKE_CASE )

               assert "f" in config._use_default_values
               assert config.f == [1, 3]

           # now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
           # **BECAUSE** it is part of `config._use_default_values`
           A_     =   SampleObjecta.from_config(config.config )
           assert new_config.f == [5, 4]

           config.config._use_default_values.pop()
           A_     =   SampleObjecta.from_config(config.config )
           assert new_config_a.f == [1, 3]

           # Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
           assert new_config_a.e == [1, 3]






