

"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a       :List[str]     =			logging.get_logger(__name__)

class   __a				(UpperCamelCase_):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE    :str							=			"""encoder-decoder"""
     _SCREAMING_SNAKE_CASE    :Any							=			True

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


           """simple docstring"""


           super().__init__(**A_	)
           assert (
               "encoder" in kwargs and "decoder" in kwargs
           ), "Config has to be initialized with encoder and decoder config"
           SCREAMING_SNAKE_CASE__ :   int   		=						kwargs.pop("""encoder"""	)
           SCREAMING_SNAKE_CASE__ :   List[str]   		=						encoder_config.pop("""model_type"""	)
           SCREAMING_SNAKE_CASE__ :   Any   		=						kwargs.pop("""decoder"""	)
           SCREAMING_SNAKE_CASE__ :   Any   		=						decoder_config.pop("""model_type"""	)

           from ..auto.configuration_auto import AutoConfig

           SCREAMING_SNAKE_CASE__ :   Optional[Any]   		=						AutoConfig.for_model(A_						,     **A_	)
           SCREAMING_SNAKE_CASE__ :   Union[str, Any]   		=						AutoConfig.for_model(A_						,     **A_	)
           SCREAMING_SNAKE_CASE__ :   Dict   		=						True

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


           """simple docstring"""


           logger.info("""Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"""	)
           SCREAMING_SNAKE_CASE__ :   Optional[Any]   		=						True
           SCREAMING_SNAKE_CASE__ :   Optional[int]   		=						True

           return cls(encoder=encoder_config.to_dict()						,     decoder=decoder_config.to_dict()						,     **A_	)





     def        _a      (    self	)	->   Tuple:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__ :   int   		=						copy.deepcopy(self.__dict__	)
           SCREAMING_SNAKE_CASE__ :   Optional[int]   		=						self.encoder.to_dict()
           SCREAMING_SNAKE_CASE__ :   Union[str, Any]   		=						self.decoder.to_dict()
           SCREAMING_SNAKE_CASE__ :   Union[str, Any]   		=						self.__class__.model_type
           return output








"""simple docstring"""




from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available




@dataclass
class 			__snake_case   (lowerCamelCase  ):
							__a					 =       42


try:
					if not (is_transformers_available() and is_torch_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
					from .pipeline_text_to_video_synth import TextToVideoSDPipeline
					from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
					from .pipeline_text_to_video_zero import TextToVideoZeroPipeline




