




import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     FalconForCausalLM,
     FalconForQuestionAnswering,
     FalconForSequenceClassification,
     FalconForTokenClassification,
     FalconModel,
 )







class 						A:



 '''simple docstring'''


 def __init__(       self      :						Optional[int]		,							A_      :						List[str]		,							A_      :						Optional[int]=3		,							A_      :						List[str]=7		,							A_      :						Dict=True		,							A_      :						Tuple=True		,							A_      :						List[Any]=False		,							A_      :						Tuple=True		,							A_      :						Union[str, Any]=99		,							A_      :						List[str]=32		,							A_      :						List[str]=5		,							A_      :						Tuple=4		,							A_      :						Union[str, Any]=37		,							A_      :						Optional[int]="gelu"		,							A_      :						str=0.1		,							A_      :						List[str]=0.1		,							A_      :						Tuple=512		,							A_      :						Any=16		,							A_      :						int=2		,							A_      :						List[Any]=0.02		,							A_      :						int=3		,							A_      :						int=4		,							A_      :						List[str]=None		,							)     ->			Optional[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					parent
       lowerCamelCase_	  =					batch_size
       lowerCamelCase_	  =					seq_length
       lowerCamelCase_	  =					is_training
       lowerCamelCase_	  =					use_input_mask
       lowerCamelCase_	  =					use_token_type_ids
       lowerCamelCase_	  =					use_labels
       lowerCamelCase_	  =					vocab_size
       lowerCamelCase_	  =					hidden_size
       lowerCamelCase_	  =					num_hidden_layers
       lowerCamelCase_	  =					num_attention_heads
       lowerCamelCase_	  =					intermediate_size
       lowerCamelCase_	  =					hidden_act
       lowerCamelCase_	  =					hidden_dropout_prob
       lowerCamelCase_	  =					attention_probs_dropout_prob
       lowerCamelCase_	  =					max_position_embeddings
       lowerCamelCase_	  =					type_vocab_size
       lowerCamelCase_	  =					type_sequence_label_size
       lowerCamelCase_	  =					initializer_range
       lowerCamelCase_	  =					num_labels
       lowerCamelCase_	  =					num_choices
       lowerCamelCase_	  =					scope

 def        a__				(       self      :						List[str]						)     ->			Optional[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					ids_tensor([self.batch_size, self.seq_length]		,							self.vocab_size						)

       lowerCamelCase_	  =					None
       if self.use_input_mask:
             lowerCamelCase_	  =					random_attention_mask([self.batch_size, self.seq_length]						)

       lowerCamelCase_	  =					None

       lowerCamelCase_	  =					None
       lowerCamelCase_	  =					None
       lowerCamelCase_	  =					None
       if self.use_labels:
             lowerCamelCase_	  =					ids_tensor([self.batch_size]		,							self.type_sequence_label_size						)
             lowerCamelCase_	  =					ids_tensor([self.batch_size, self.seq_length]		,							self.num_labels						)
             lowerCamelCase_	  =					ids_tensor([self.batch_size]		,							self.num_choices						)

       lowerCamelCase_	  =					self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

 def        a__				(       self      :						List[str]						)     ->			Union[str, Any]:

       """simple docstring"""






       return FalconConfig(
           vocab_size=self.vocab_size		,							hidden_size=self.hidden_size		,							num_hidden_layers=self.num_hidden_layers		,							num_attention_heads=self.num_attention_heads		,							intermediate_size=self.intermediate_size		,							hidden_act=self.hidden_act		,							hidden_dropout_prob=self.hidden_dropout_prob		,							attention_probs_dropout_prob=self.attention_probs_dropout_prob		,							max_position_embeddings=self.max_position_embeddings		,							type_vocab_size=self.type_vocab_size		,							is_decoder=A_		,							initializer_range=self.initializer_range		,							pad_token_id=1		,							new_decoder_architecture=A_		,							)

 def        a__				(       self      :						Optional[int]		,							A_      :						str		,							A_      :						str		,							A_      :						str		,							A_      :						List[str]		,							A_      :						Optional[int]		,							A_      :						Union[str, Any]		,							A_      :						int						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					FalconModel(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_						)
       lowerCamelCase_	  =					model(A_						)
       self.parent.assertEqual(result.last_hidden_state.shape		,							(self.batch_size, self.seq_length, self.hidden_size)						)

 def        a__				(       self      :						Any		,							A_      :						Optional[int]		,							A_      :						Any		,							A_      :						List[str]		,							A_      :						Union[str, Any]		,							A_      :						Optional[Any]		,							A_      :						Union[str, Any]		,							A_      :						Optional[Any]		,							A_      :						Optional[int]		,							A_      :						Tuple		,							)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					True
       lowerCamelCase_	  =					FalconModel(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(
           A_		,							attention_mask=A_		,							encoder_hidden_states=A_		,							encoder_attention_mask=A_		,							)
       lowerCamelCase_	  =					model(
           A_		,							attention_mask=A_		,							encoder_hidden_states=A_		,							)
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_						)
       self.parent.assertEqual(result.last_hidden_state.shape		,							(self.batch_size, self.seq_length, self.hidden_size)						)

 def        a__				(       self      :						Optional[int]		,							A_      :						Dict		,							A_      :						Any		,							A_      :						Union[str, Any]		,							A_      :						Optional[Any]		,							A_      :						str		,							A_      :						Optional[Any]		,							A_      :						Dict		,							A_      :						List[str]		,							A_      :						Union[str, Any]		,							)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					FalconForCausalLM(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_		,							labels=A_						)
       self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.seq_length, self.vocab_size)						)

 def        a__				(       self      :						Tuple		,							A_      :						str		,							A_      :						Any		,							A_      :						List[Any]		,							A_      :						List[str]		,							A_      :						Dict		,							A_      :						str		,							A_      :						Union[str, Any]		,							A_      :						int		,							A_      :						List[Any]		,							)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_	  =					True
       lowerCamelCase_	  =					True
       lowerCamelCase_	  =					FalconForCausalLM(config=A_						)
       model.to(A_						)
       model.eval()

       # first forward pass
       lowerCamelCase_	  =					model(
           A_		,							attention_mask=A_		,							encoder_hidden_states=A_		,							encoder_attention_mask=A_		,							use_cache=A_		,							)
       lowerCamelCase_	  =					outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       lowerCamelCase_	  =					ids_tensor((self.batch_size, 3)		,							config.vocab_size						)
       lowerCamelCase_	  =					ids_tensor((self.batch_size, 3)		,							vocab_size=2						)

       # append to next input_ids and
       lowerCamelCase_	  =					torch.cat([input_ids, next_tokens]		,							dim=-1						)
       lowerCamelCase_	  =					torch.cat([input_mask, next_mask]		,							dim=-1						)

       lowerCamelCase_	  =					model(
           A_		,							attention_mask=A_		,							encoder_hidden_states=A_		,							encoder_attention_mask=A_		,							output_hidden_states=A_		,							)['hidden_states'][0]
       lowerCamelCase_	  =					model(
           A_		,							attention_mask=A_		,							encoder_hidden_states=A_		,							encoder_attention_mask=A_		,							past_key_values=A_		,							output_hidden_states=A_		,							)['hidden_states'][0]

       # select random slice
       lowerCamelCase_	  =					ids_tensor((1,)		,							output_from_past.shape[-1]						).item()
       lowerCamelCase_	  =					output_from_no_past[:, -3:, random_slice_idx].detach()
       lowerCamelCase_	  =					output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]						)

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(A_		,							A_		,							atol=1E-3						)						)





 def        a__				(       self      :						Optional[Any]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_	  =					self.prepare_config_and_inputs()
       (
           (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       (
           lowerCamelCase_
       )  ,       
       )	  =					config_and_inputs
       lowerCamelCase_	  =					{'input_ids': input_ids, 'attention_mask': input_mask}
       return config, inputs_dict







@require_torch
class 						A(		UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		(
     (
         FalconModel,
         FalconForCausalLM,
         FalconForSequenceClassification,
         FalconForTokenClassification,
         FalconForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 UpperCamelCase		     =		(FalconForCausalLM,) if is_torch_available() else ()
 UpperCamelCase		     =		(
     {
         '''feature-extraction''': FalconModel,
         '''text-classification''': FalconForSequenceClassification,
         '''text-generation''': FalconForCausalLM,
         '''question-answering''': FalconForQuestionAnswering,
         '''token-classification''': FalconForTokenClassification,
         '''zero-shot''': FalconForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 UpperCamelCase		     =		False
 UpperCamelCase		     =		False

 def        a__				(       self      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					FalconModelTester(self						)
       lowerCamelCase_	  =					ConfigTester(self		,							config_class=A_		,							hidden_size=37						)

 def        a__				(       self      :						Any						)     ->			int:

       """simple docstring"""






       self.config_tester.run_common_tests()

 def        a__				(       self      :						Optional[Any]						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_						)

 def        a__				(       self      :						List[str]						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_  ,       *lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       for alibi in [True, False]:
             lowerCamelCase_	  =					alibi
             self.model_tester.create_and_check_model(A_		,							*A_						)

 def        a__				(       self      :						Dict						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase_	  =					3
       lowerCamelCase_	  =					input_dict['input_ids']
       lowerCamelCase_	  =					input_ids.ne(1						).to(A_						)
       lowerCamelCase_	  =					ids_tensor([self.model_tester.batch_size]		,							self.model_tester.type_sequence_label_size						)
       lowerCamelCase_	  =					FalconForSequenceClassification(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_		,							labels=A_						)
       self.assertEqual(result.logits.shape		,							(self.model_tester.batch_size, self.model_tester.num_labels)						)

 def        a__				(       self      :						List[Any]						)     ->			int:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase_	  =					3
       lowerCamelCase_	  =					'single_label_classification'
       lowerCamelCase_	  =					input_dict['input_ids']
       lowerCamelCase_	  =					input_ids.ne(1						).to(A_						)
       lowerCamelCase_	  =					ids_tensor([self.model_tester.batch_size]		,							self.model_tester.type_sequence_label_size						)
       lowerCamelCase_	  =					FalconForSequenceClassification(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_		,							labels=A_						)
       self.assertEqual(result.logits.shape		,							(self.model_tester.batch_size, self.model_tester.num_labels)						)

 def        a__				(       self      :						List[str]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase_	  =					input_dict['input_ids']
       lowerCamelCase_	  =					FalconForCausalLM(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							use_cache=A_						)
       lowerCamelCase_	  =					input_ids.shape[0]
       lowerCamelCase_	  =					model._convert_to_rw_cache(result.past_key_values						)
       lowerCamelCase_	  =					model._convert_cache_to_standard_format(A_		,							A_						)
       for layer in range(len(A_						)						):
             for tensor_idx in range(2						):
                   self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3						)
                   self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4						)
                   self.assertTrue(
                       torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]						)						)

 def        a__				(       self      :						Dict						)     ->			str:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase_	  =					3
       lowerCamelCase_	  =					'multi_label_classification'
       lowerCamelCase_	  =					input_dict['input_ids']
       lowerCamelCase_	  =					input_ids.ne(1						).to(A_						)
       lowerCamelCase_	  =					ids_tensor(
           [self.model_tester.batch_size, config.num_labels]		,							self.model_tester.type_sequence_label_size						).to(torch.float						)
       lowerCamelCase_	  =					FalconForSequenceClassification(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							attention_mask=A_		,							labels=A_						)
       self.assertEqual(result.logits.shape		,							(self.model_tester.batch_size, self.model_tester.num_labels)						)





 def        a__				(       self      :						str						)     ->			Dict:

       """simple docstring"""






       for model_class in self.all_generative_model_classes:
             lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

             # If it doesn't support cache, pass the test
             if not hasattr(A_		,							'use_cache'						):
                   return

             lowerCamelCase_	  =					model_class(A_						).to(A_						)
             if "use_cache" not in inputs:
                   lowerCamelCase_	  =					True
             lowerCamelCase_	  =					model(**A_						)

             # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
             if "past_key_values" not in outputs:
                   return

             lowerCamelCase_	  =					(
                 getattr(A_		,							'decoder_layers'		,							A_						)
                 or getattr(A_		,							'num_decoder_layers'		,							A_						)
                 or config.num_hidden_layers
             )
             lowerCamelCase_	  =					getattr(A_		,							'num_kv_heads'		,							config.num_attention_heads						)
             lowerCamelCase_	  =					getattr(A_		,							'd_model'		,							config.hidden_size						)
             lowerCamelCase_	  =					embed_dim // num_attention_heads

             lowerCamelCase_	  =					outputs['past_key_values']
             self.assertEqual(len(A_						)		,							A_						)

             lowerCamelCase_  ,       lowerCamelCase_	  =					inputs['input_ids'].shape
             for i in range(A_						):
                   if config.new_decoder_architecture:
                         lowerCamelCase_	  =					config.num_attention_heads
                   elif config.multi_query:
                         lowerCamelCase_	  =					1
                   self.assertEqual(len(past_kv[0]						)		,							2						)  # K V for the decoder = 2
                   self.assertEqual(
                       past_kv[i][0].shape		,							(batch_size, num_attention_heads, seq_length, per_head_embed_dim)						)
                   self.assertEqual(
                       past_kv[i][1].shape		,							(batch_size, num_attention_heads, seq_length, per_head_embed_dim)						)







@require_torch
class 						A(		unittest.TestCase     ):



 '''simple docstring'''


 @slow
 def        a__				(       self      :						Any						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'						)
       lowerCamelCase_	  =					FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'						)
       model.eval()
       model.to(A_						)
       lowerCamelCase_	  =					tokenizer('My favorite food is'		,							return_tensors='pt'						).to(A_						)

       lowerCamelCase_	  =					(
           'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
       )

       lowerCamelCase_	  =					model.generate(**A_		,							do_sample=A_		,							max_new_tokens=19						)
       lowerCamelCase_	  =					tokenizer.batch_decode(A_						)[0]

       self.assertEqual(A_		,							A_						)

 @slow
 def        a__				(       self      :						List[str]						)     ->			Optional[int]:

       """simple docstring"""






       for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
             lowerCamelCase_	  =					AutoTokenizer.from_pretrained(A_						)
             lowerCamelCase_	  =					FalconForCausalLM.from_pretrained(A_						)
             model.eval()
             model.to(A_						)
             lowerCamelCase_	  =					tokenizer('My favorite food is'		,							return_tensors='pt'						).to(A_						)

             # We just test that these run without errors - the models are randomly initialized
             # and so the actual text outputs will be garbage
             model.generate(**A_		,							do_sample=A_		,							max_new_tokens=4						)
             model.generate(**A_		,							do_sample=A_		,							max_new_tokens=4						)
             model.generate(**A_		,							num_beams=2		,							max_new_tokens=4						)





 @slow
 def        a__				(       self      :						str						)     ->			Optional[int]:

       """simple docstring"""






       with torch.no_grad():
             for repo in [
                 "Rocketknight1/falcon-rw-1b",
                 "Rocketknight1/tiny-random-falcon-7b",
                 "Rocketknight1/tiny-random-falcon-40b",
             ]:
                   lowerCamelCase_	  =					AutoTokenizer.from_pretrained(A_						)
                   lowerCamelCase_	  =					FalconForCausalLM.from_pretrained(A_						)
                   model.eval()
                   model.to(device=A_						)
                   lowerCamelCase_	  =					tokenizer('My favorite food is'		,							return_tensors='pt'						).to(A_						)

                   # Test results are the same with and without cache
                   lowerCamelCase_	  =					model.generate(**A_		,							do_sample=A_		,							max_new_tokens=20		,							use_cache=A_						)
                   lowerCamelCase_	  =					model.generate(**A_		,							do_sample=A_		,							max_new_tokens=20		,							use_cache=A_						)
                   self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0						)









import os
import re
import shutil
import sys
import tempfile
import unittest

import black


lowerCamelCase       :	List[Any]									=     os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, "utils"))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If DDPMSchedulerOutput is changed in scheduling_ddpm.py, this code needs to be manually updated.
lowerCamelCase       :	Tuple									=     "    \"\"\"\n    Output class for the scheduler's step function output.\n\n    Args:\n        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n            Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the\n            denoising loop.\n        pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n            The predicted denoised sample (x_{0}) based on the model output from the current timestep.\n            `pred_original_sample` can be used to preview progress or for guidance.\n    \"\"\"\n\n    prev_sample: torch.FloatTensor\n    pred_original_sample: Optional[torch.FloatTensor] = None\n"







class 						A(		unittest.TestCase     ):



 '''simple docstring'''


 def        a__				(       self      :						Union[str, Any]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					tempfile.mkdtemp()
       os.makedirs(os.path.join(self.diffusers_dir		,							'schedulers/'						)						)
       lowerCamelCase_	  =					self.diffusers_dir
       shutil.copy(
           os.path.join(A_		,							'src/diffusers/schedulers/scheduling_ddpm.py'						)		,							os.path.join(self.diffusers_dir		,							'schedulers/scheduling_ddpm.py'						)		,							)

 def        a__				(       self      :						Tuple						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					'src/diffusers'
       shutil.rmtree(self.diffusers_dir						)

 def        a__				(       self      :						str		,							A_      :						Optional[Any]		,							A_      :						Optional[int]		,							A_      :						str		,							A_      :						Optional[Any]=None						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					comment + f"""\nclass {class_name}(nn.Module):\n""" + class_code
       if overwrite_result is not None:
             lowerCamelCase_	  =					comment + f"""\nclass {class_name}(nn.Module):\n""" + overwrite_result
       lowerCamelCase_	  =					black.Mode(target_versions={black.TargetVersion.PYaa}		,							line_length=119						)
       lowerCamelCase_	  =					black.format_str(A_		,							mode=A_						)
       lowerCamelCase_	  =					os.path.join(self.diffusers_dir		,							'new_code.py'						)
       with open(A_		,							'w'		,							newline='\n'						) as f:
             f.write(A_						)
       if overwrite_result is None:
             self.assertTrue(len(check_copies.is_copy_consistent(A_						)						) == 0						)
       else:
             check_copies.is_copy_consistent(f.name		,							overwrite=A_						)
             with open(A_		,							'r'						) as f:
                   self.assertTrue(f.read()		,							A_						)

 def        a__				(       self      :						Optional[int]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					check_copies.find_code_in_diffusers('schedulers.scheduling_ddpm.DDPMSchedulerOutput'						)
       self.assertEqual(A_		,							A_						)





 def        a__				(       self      :						Any						)     ->			Dict:

       """simple docstring"""






       self.check_copy_consistency(
           '# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput'		,							'DDPMSchedulerOutput'		,							REFERENCE_CODE + '\n'		,							)

       # With no empty line at the end
       self.check_copy_consistency(
           '# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput'		,							'DDPMSchedulerOutput'		,							A_		,							)

       # Copy consistency with rename
       self.check_copy_consistency(
           '# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test'		,							'TestSchedulerOutput'		,							re.sub('DDPM'		,							'Test'		,							A_						)		,							)

       # Copy consistency with a really long name
       lowerCamelCase_	  =					'TestClassWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'
       self.check_copy_consistency(
           f"""# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->{long_class_name}"""		,							f"""{long_class_name}SchedulerOutput"""		,							re.sub('Bert'		,							A_		,							A_						)		,							)

       # Copy consistency with overwrite
       self.check_copy_consistency(
           '# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test'		,							'TestSchedulerOutput'		,							A_		,							overwrite_result=re.sub('DDPM'		,							'Test'		,							A_						)		,							)



