

import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np







class 						__magic_name__			:

   '''simple docstring'''




   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     torch.manual_seed(0       )
     a__  =TaEncoderModel.from_pretrained('''hf-internal-testing/tiny-random-t5'''       )

     torch.manual_seed(0       )
     a__  =AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-t5'''       )

     torch.manual_seed(0       )
     a__  =UNetaDConditionModel(
         sample_size=32,    layers_per_block=1,    block_out_channels=[32, 64],    down_block_types=[
             '''ResnetDownsampleBlock2D''',
             '''SimpleCrossAttnDownBlock2D''',
         ],    mid_block_type='''UNetMidBlock2DSimpleCrossAttn''',    up_block_types=['''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''],    in_channels=3,    out_channels=6,    cross_attention_dim=32,    encoder_hid_dim=32,    attention_head_dim=8,    addition_embed_type='''text''',    addition_embed_type_num_heads=2,    cross_attention_norm='''group_norm''',    resnet_time_scale_shift='''scale_shift''',    act_fn='''gelu''',    )
     unet.set_attn_processor(AttnAddedKVProcessor()       )  # For reproducibility tests

     torch.manual_seed(0       )
     a__  =DDPMScheduler(
         num_train_timesteps=1000,    beta_schedule='''squaredcos_cap_v2''',    beta_start=0.0001,    beta_end=0.02,    thresholding=lowercase_,    dynamic_thresholding_ratio=0.95,    sample_max_value=1.0,    prediction_type='''epsilon''',    variance_type='''learned_range''',    )

     torch.manual_seed(0       )
     a__  =IFWatermarker()

     return {
         "text_encoder": text_encoder,
         "tokenizer": tokenizer,
         "unet": unet,
         "scheduler": scheduler,
         "watermarker": watermarker,
         "safety_checker": None,
         "feature_extractor": None,
     }



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     torch.manual_seed(0       )
     a__  =TaEncoderModel.from_pretrained('''hf-internal-testing/tiny-random-t5'''       )

     torch.manual_seed(0       )
     a__  =AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-t5'''       )

     torch.manual_seed(0       )
     a__  =UNetaDConditionModel(
         sample_size=32,    layers_per_block=[1, 2],    block_out_channels=[32, 64],    down_block_types=[
             '''ResnetDownsampleBlock2D''',
             '''SimpleCrossAttnDownBlock2D''',
         ],    mid_block_type='''UNetMidBlock2DSimpleCrossAttn''',    up_block_types=['''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''],    in_channels=6,    out_channels=6,    cross_attention_dim=32,    encoder_hid_dim=32,    attention_head_dim=8,    addition_embed_type='''text''',    addition_embed_type_num_heads=2,    cross_attention_norm='''group_norm''',    resnet_time_scale_shift='''scale_shift''',    act_fn='''gelu''',    class_embed_type='''timestep''',    mid_block_scale_factor=1.414,    time_embedding_act_fn='''gelu''',    time_embedding_dim=32,    )
     unet.set_attn_processor(AttnAddedKVProcessor()       )  # For reproducibility tests

     torch.manual_seed(0       )
     a__  =DDPMScheduler(
         num_train_timesteps=1000,    beta_schedule='''squaredcos_cap_v2''',    beta_start=0.0001,    beta_end=0.02,    thresholding=lowercase_,    dynamic_thresholding_ratio=0.95,    sample_max_value=1.0,    prediction_type='''epsilon''',    variance_type='''learned_range''',    )

     torch.manual_seed(0       )
     a__  =DDPMScheduler(
         num_train_timesteps=1000,    beta_schedule='''squaredcos_cap_v2''',    beta_start=0.0001,    beta_end=0.02,    )

     torch.manual_seed(0       )
     a__  =IFWatermarker()

     return {
         "text_encoder": text_encoder,
         "tokenizer": tokenizer,
         "unet": unet,
         "scheduler": scheduler,
         "image_noising_scheduler": image_noising_scheduler,
         "watermarker": watermarker,
         "safety_checker": None,
         "feature_extractor": None,
     }



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






     """simple docstring"""






     a__  =self.get_dummy_components()
     a__  =self.pipeline_class(**lowercase_       )
     pipe.to(lowercase_       )
     pipe.set_progress_bar_config(disable=lowercase_       )

     a__  =self.get_dummy_inputs(lowercase_       )

     a__  =inputs['''prompt''']
     a__  =inputs['''generator''']
     a__  =inputs['''num_inference_steps''']
     a__  =inputs['''output_type''']

     if "image" in inputs:
       a__  =inputs['''image''']
     else:
       a__  =None

     if "mask_image" in inputs:
       a__  =inputs['''mask_image''']
     else:
       a__  =None

     if "original_image" in inputs:
       a__  =inputs['''original_image''']
     else:
       a__  =None

     a__,      a__  =pipe.encode_prompt(lowercase_       )

     # inputs with prompt converted to embeddings
     a__  ={
         '''prompt_embeds''': prompt_embeds,
         '''negative_prompt_embeds''': negative_prompt_embeds,
         '''generator''': generator,
         '''num_inference_steps''': num_inference_steps,
         '''output_type''': output_type,
     }

     if image is not None:
       a__  =image

     if mask_image is not None:
       a__  =mask_image

     if original_image is not None:
       a__  =original_image

     # set all optional components to None
     for optional_component in pipe._optional_components:
       setattr(lowercase_,    lowercase_,    lowercase_       )

     a__  =pipe(**lowercase_       )[0]

     with tempfile.TemporaryDirectory() as tmpdir:
       pipe.save_pretrained(lowercase_       )
       a__  =self.pipeline_class.from_pretrained(lowercase_       )
       pipe_loaded.to(lowercase_       )
       pipe_loaded.set_progress_bar_config(disable=lowercase_       )

     pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()       )  # For reproducibility tests

     for optional_component in pipe._optional_components:
       self.assertTrue(
           getattr(lowercase_,    lowercase_       ) is None,    F"""`{optional_component}` did not stay set to None after loading.""",    )

     a__  =self.get_dummy_inputs(lowercase_       )

     a__  =inputs['''generator''']
     a__  =inputs['''num_inference_steps''']
     a__  =inputs['''output_type''']

     # inputs with prompt converted to embeddings
     a__  ={
         '''prompt_embeds''': prompt_embeds,
         '''negative_prompt_embeds''': negative_prompt_embeds,
         '''generator''': generator,
         '''num_inference_steps''': num_inference_steps,
         '''output_type''': output_type,
     }

     if image is not None:
       a__  =image

     if mask_image is not None:
       a__  =mask_image

     if original_image is not None:
       a__  =original_image

     a__  =pipe_loaded(**lowercase_       )[0]

     a__  =np.abs(to_np(lowercase_       ) - to_np(lowercase_       )       ).max()
     self.assertLess(lowercase_,    1E-4       )



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =self.get_dummy_components()
     a__  =self.pipeline_class(**lowercase_       )
     pipe.to(lowercase_       )
     pipe.set_progress_bar_config(disable=lowercase_       )

     a__  =self.get_dummy_inputs(lowercase_       )
     a__  =pipe(**lowercase_       )[0]

     with tempfile.TemporaryDirectory() as tmpdir:
       pipe.save_pretrained(lowercase_       )
       a__  =self.pipeline_class.from_pretrained(lowercase_       )
       pipe_loaded.to(lowercase_       )
       pipe_loaded.set_progress_bar_config(disable=lowercase_       )

     pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()       )  # For reproducibility tests

     a__  =self.get_dummy_inputs(lowercase_       )
     a__  =pipe_loaded(**lowercase_       )[0]

     a__  =np.abs(to_np(lowercase_       ) - to_np(lowercase_       )       ).max()
     self.assertLess(lowercase_,    1E-4       )



from ..utils import DummyObject, requires_backends







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )





def 			UpperCAmelCase__				(			*_A      : Optional[Any]	,      **_A      : Optional[Any]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Union[str, Any]	,      **_A      : List[Any]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Union[str, Any]	,      **_A      : Tuple							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : List[str]	,      **_A      : List[str]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Dict	,      **_A      : Dict							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : List[str]	,      **_A      : str							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Optional[int]	,      **_A      : Dict							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[int]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )
