


import copy

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


__magic_name__       					=      logging.get_logger(__name__)





class    lowerCAmelCase__				(			__lowerCamelCase       ):






						"""simple docstring"""
						__UpperCAmelCase   :		Tuple  					=	'''hybrid-clip'''
						__UpperCAmelCase   :		Tuple  					=	True




						def __init__(   self				,							a_=512				,							**a_     ):
							super().__init__(**a_     )

							if "text_config" not in kwargs:
								raise ValueError("`text_config` can not be `None`."     )

							if "vision_config" not in kwargs:
								raise ValueError("`vision_config` can not be `None`."     )

							lowerCamelCase_			:							int      =       kwargs.pop("text_config"     )
							lowerCamelCase_			:							Optional[Any]      =       kwargs.pop("vision_config"     )

							lowerCamelCase_			:							int      =       text_config.pop("model_type"     )
							lowerCamelCase_			:							Dict      =       vision_config.pop("model_type"     )

							from transformers import AutoConfig

							lowerCamelCase_			:							Dict      =       AutoConfig.for_model(a_				,							**a_     )

							if vision_model_type == "clip":
								lowerCamelCase_			:							Tuple      =       AutoConfig.for_model(a_				,							**a_     ).vision_config
							elif vision_model_type == "clip_vision_model":
								from transformers import CLIPVisionConfig

								lowerCamelCase_			:							int      =       CLIPVisionConfig(**a_     )
							else:
								lowerCamelCase_			:							List[str]      =       AutoConfig.for_model(a_				,							**a_     )

							lowerCamelCase_			:							Tuple      =       projection_dim
							lowerCamelCase_			:							Tuple      =       1.0




						@classmethod
						def 					_UpperCamelCase			(   cls				,							a_				,							a_				,							**a_     ):
							return cls(text_config=text_config.to_dict()				,							vision_config=vision_config.to_dict()				,							**a_     )




						def 					_UpperCamelCase			(   self     ):
							lowerCamelCase_			:							List[Any]      =       copy.deepcopy(self.__dict__     )
							lowerCamelCase_			:							List[Any]      =       self.text_config.to_dict()
							lowerCamelCase_			:							Union[str, Any]      =       self.vision_config.to_dict()
							lowerCamelCase_			:							Union[str, Any]      =       self.__class__.model_type
							return output





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__magic_name__       					=      {
    '''configuration_big_bird''': ['''BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BigBirdConfig''', '''BigBirdOnnxConfig'''],
}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__magic_name__       					=      ['''BigBirdTokenizer''']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__magic_name__       					=      ['''BigBirdTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__magic_name__       					=      [
							    '''BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''BigBirdForCausalLM''',
							    '''BigBirdForMaskedLM''',
							    '''BigBirdForMultipleChoice''',
							    '''BigBirdForPreTraining''',
							    '''BigBirdForQuestionAnswering''',
							    '''BigBirdForSequenceClassification''',
							    '''BigBirdForTokenClassification''',
							    '''BigBirdLayer''',
							    '''BigBirdModel''',
							    '''BigBirdPreTrainedModel''',
							    '''load_tf_weights_in_big_bird''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__magic_name__       					=      [
							    '''FlaxBigBirdForCausalLM''',
							    '''FlaxBigBirdForMaskedLM''',
							    '''FlaxBigBirdForMultipleChoice''',
							    '''FlaxBigBirdForPreTraining''',
							    '''FlaxBigBirdForQuestionAnswering''',
							    '''FlaxBigBirdForSequenceClassification''',
							    '''FlaxBigBirdForTokenClassification''',
							    '''FlaxBigBirdModel''',
							    '''FlaxBigBirdPreTrainedModel''',
							]

if TYPE_CHECKING:
							from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_big_bird import BigBirdTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_big_bird_fast import BigBirdTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_big_bird import (
														    BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
														    BigBirdForCausalLM,
														    BigBirdForMaskedLM,
														    BigBirdForMultipleChoice,
														    BigBirdForPreTraining,
														    BigBirdForQuestionAnswering,
														    BigBirdForSequenceClassification,
														    BigBirdForTokenClassification,
														    BigBirdLayer,
														    BigBirdModel,
														    BigBirdPreTrainedModel,
														    load_tf_weights_in_big_bird,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_big_bird import (
														    FlaxBigBirdForCausalLM,
														    FlaxBigBirdForMaskedLM,
														    FlaxBigBirdForMultipleChoice,
														    FlaxBigBirdForPreTraining,
														    FlaxBigBirdForQuestionAnswering,
														    FlaxBigBirdForSequenceClassification,
														    FlaxBigBirdForTokenClassification,
														    FlaxBigBirdModel,
														    FlaxBigBirdPreTrainedModel,
														)

else:
							import sys

							__magic_name__       					=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

