


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


a					:				str       =      {
    'configuration_esm': ['ESM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'EsmConfig'],
    'tokenization_esm': ['EsmTokenizer'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a					:				Any       =      [
      'ESM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'EsmForMaskedLM',
      'EsmForSequenceClassification',
      'EsmForTokenClassification',
      'EsmModel',
      'EsmPreTrainedModel',
  ]
  a					:				Any       =      ['EsmForProteinFolding', 'EsmFoldPreTrainedModel']

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a					:				List[str]       =      [
      'TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFEsmForMaskedLM',
      'TFEsmForSequenceClassification',
      'TFEsmForTokenClassification',
      'TFEsmModel',
      'TFEsmPreTrainedModel',
  ]

if TYPE_CHECKING:
  from .configuration_esm import ESM_PRETRAINED_CONFIG_ARCHIVE_MAP, EsmConfig
  from .tokenization_esm import EsmTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_esm import (
        ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
        EsmForMaskedLM,
        EsmForSequenceClassification,
        EsmForTokenClassification,
        EsmModel,
        EsmPreTrainedModel,
    )
    from .modeling_esmfold import EsmFoldPreTrainedModel, EsmForProteinFolding

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_esm import (
        TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFEsmForMaskedLM,
        TFEsmForSequenceClassification,
        TFEsmForTokenClassification,
        TFEsmModel,
        TFEsmPreTrainedModel,
    )


else:
  import sys

  a					:				List[Any]       =      _LazyModule(__name__, globals()['__file__'], _import_structure)










import copy

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


a					:				Optional[Any]       =      logging.get_logger(__name__)

class   lowerCamelCase						(	SCREAMING_SNAKE_CASE  ):
       _UpperCamelCase     		=   """hybrid-clip"""
       _UpperCamelCase     		=   True

       def __init__(      self						,    a__=5_12						,    **a__       ):






        '''simple docstring'''






        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`.'''       )

        snake_case :			int							=   kwargs.pop('''text_config'''       )
        snake_case :			Optional[int]							=   kwargs.pop('''vision_config'''       )

        snake_case :			Optional[Any]							=   text_config.pop('''model_type'''       )
        snake_case :			str							=   vision_config.pop('''model_type'''       )

        from transformers import AutoConfig

        snake_case :			List[Any]							=   AutoConfig.for_model(a__						,    **a__       )

        if vision_model_type == "clip":
         snake_case :			Dict							=   AutoConfig.for_model(a__						,    **a__       ).vision_config
        elif vision_model_type == "clip_vision_model":
         from transformers import CLIPVisionConfig

         snake_case :			str							=   CLIPVisionConfig(**a__       )
        else:
         snake_case :			Any							=   AutoConfig.for_model(a__						,    **a__       )

        snake_case :			Optional[Any]							=   projection_dim
        snake_case :			int							=   1.0

       @classmethod
       def 					UpperCAmelCase					(      cls						,    a__						,    a__						,    **a__       ):






        '''simple docstring'''






        return cls(text_config=text_config.to_dict()						,    vision_config=vision_config.to_dict()						,    **a__       )



       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Dict							=   copy.deepcopy(self.__dict__       )
        snake_case :			Dict							=   self.text_config.to_dict()
        snake_case :			int							=   self.vision_config.to_dict()
        snake_case :			List[Any]							=   self.__class__.model_type
        return output






