





"""simple docstring"""
import copy
import os
from typing import Union

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


lowerCamelCase_       =		logging.get_logger(__name__)

lowerCamelCase_       =		{
    "BAAI/AltCLIP": "https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json",
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}






class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  '''altclip_text_model'''




       def __init__(						self		,SCREAMING_SNAKE_CASE__=25_00_02		,SCREAMING_SNAKE_CASE__=10_24		,SCREAMING_SNAKE_CASE__=24		,SCREAMING_SNAKE_CASE__=16		,SCREAMING_SNAKE_CASE__=40_96		,SCREAMING_SNAKE_CASE__="gelu"		,SCREAMING_SNAKE_CASE__=0.1		,SCREAMING_SNAKE_CASE__=0.1		,SCREAMING_SNAKE_CASE__=5_14		,SCREAMING_SNAKE_CASE__=1		,SCREAMING_SNAKE_CASE__=0.0_2		,SCREAMING_SNAKE_CASE__=0.0_2		,SCREAMING_SNAKE_CASE__=1E-05		,SCREAMING_SNAKE_CASE__=1		,SCREAMING_SNAKE_CASE__=0		,SCREAMING_SNAKE_CASE__=2		,SCREAMING_SNAKE_CASE__="absolute"		,SCREAMING_SNAKE_CASE__=True		,SCREAMING_SNAKE_CASE__=7_68		,**SCREAMING_SNAKE_CASE__		,)      ->				List[Any]:





             """simple docstring"""






             super().__init__(pad_token_id=SCREAMING_SNAKE_CASE__		,bos_token_id=SCREAMING_SNAKE_CASE__		,eos_token_id=SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE       :List[Any]		    =  vocab_size
             __SCREAMING_SNAKE_CASE       :int		    =  hidden_size
             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  num_hidden_layers
             __SCREAMING_SNAKE_CASE       :str		    =  num_attention_heads
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  hidden_act
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  intermediate_size
             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  hidden_dropout_prob
             __SCREAMING_SNAKE_CASE       :List[str]		    =  attention_probs_dropout_prob
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  max_position_embeddings
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  type_vocab_size
             __SCREAMING_SNAKE_CASE       :int		    =  initializer_range
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  initializer_factor
             __SCREAMING_SNAKE_CASE       :Any		    =  layer_norm_eps
             __SCREAMING_SNAKE_CASE       :Any		    =  position_embedding_type
             __SCREAMING_SNAKE_CASE       :int		    =  use_cache
             __SCREAMING_SNAKE_CASE       :str		    =  project_dim






class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				str     						=  '''altclip_vision_model'''




       def __init__(						self		,SCREAMING_SNAKE_CASE__=7_68		,SCREAMING_SNAKE_CASE__=30_72		,SCREAMING_SNAKE_CASE__=5_12		,SCREAMING_SNAKE_CASE__=12		,SCREAMING_SNAKE_CASE__=12		,SCREAMING_SNAKE_CASE__=3		,SCREAMING_SNAKE_CASE__=2_24		,SCREAMING_SNAKE_CASE__=32		,SCREAMING_SNAKE_CASE__="quick_gelu"		,SCREAMING_SNAKE_CASE__=1E-5		,SCREAMING_SNAKE_CASE__=0.0		,SCREAMING_SNAKE_CASE__=0.0_2		,SCREAMING_SNAKE_CASE__=1.0		,**SCREAMING_SNAKE_CASE__		,)      ->				Any:





             """simple docstring"""






             super().__init__(**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE       :List[str]		    =  hidden_size
             __SCREAMING_SNAKE_CASE       :str		    =  intermediate_size
             __SCREAMING_SNAKE_CASE       :Any		    =  projection_dim
             __SCREAMING_SNAKE_CASE       :Any		    =  num_hidden_layers
             __SCREAMING_SNAKE_CASE       :Any		    =  num_attention_heads
             __SCREAMING_SNAKE_CASE       :Any		    =  num_channels
             __SCREAMING_SNAKE_CASE       :Any		    =  patch_size
             __SCREAMING_SNAKE_CASE       :Dict		    =  image_size
             __SCREAMING_SNAKE_CASE       :List[str]		    =  initializer_range
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  initializer_factor
             __SCREAMING_SNAKE_CASE       :Any		    =  attention_dropout
             __SCREAMING_SNAKE_CASE       :Dict		    =  layer_norm_eps
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  hidden_act




       @classmethod
       def    _UpperCamelCase					(						cls		,SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)      ->				"PretrainedConfig":





             """simple docstring"""






             cls._set_token_in_kwargs(SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE       :Dict		    =  cls.get_config_dict(SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)

             # get the vision config dict if we are loading from AltCLIPConfig
             if config_dict.get('''model_type'''							) == "altclip":
                   __SCREAMING_SNAKE_CASE       :Dict		    =  config_dict['''vision_config''']

             if "model_type" in config_dict and hasattr(cls		,'''model_type'''							) and config_dict["model_type"] != cls.model_type:
                   logger.warning(
                       f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
                       f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''							)

             return cls.from_dict(SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)






class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				Optional[int]     						=  '''altclip'''
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  True




       def __init__(						self		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=7_68		,SCREAMING_SNAKE_CASE__=2.6_5_9_2		,**SCREAMING_SNAKE_CASE__							)      ->				Union[str, Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  kwargs.pop('''text_config_dict'''		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE       :str		    =  kwargs.pop('''vision_config_dict'''		,SCREAMING_SNAKE_CASE__							)

             super().__init__(**SCREAMING_SNAKE_CASE__							)

             # Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
             # `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
             # cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
             if text_config_dict is not None:
                   if text_config is None:
                         __SCREAMING_SNAKE_CASE       :Any		    =  {}

                   # This is the complete result when using `text_config_dict`.
                   __SCREAMING_SNAKE_CASE       :List[str]		    =  AltCLIPTextConfig(**SCREAMING_SNAKE_CASE__							).to_dict()

                   # Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
                   for key, value in _text_config_dict.items():
                         if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
                               # If specified in `text_config_dict`
                               if key in text_config_dict:
                                     __SCREAMING_SNAKE_CASE       :int		    =  (
                                         f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
                                         f'''The value `text_config_dict["{key}"]` will be used instead.'''
                                     )
                               # If inferred from default argument values (just to be super careful)
                               else:
                                     __SCREAMING_SNAKE_CASE       :List[Any]		    =  (
                                         f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
                                         f'''value `text_config["{key}"]` will be overriden.'''
                                     )
                               logger.warning(SCREAMING_SNAKE_CASE__							)

            # Update all values in `text_config` with the ones in `_text_config_dict`.
                   text_config.update(_text_config_dict							)

             if vision_config_dict is not None:
                   if vision_config is None:
                         __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  {}

                   # This is the complete result when using `vision_config_dict`.
                   __SCREAMING_SNAKE_CASE       :str		    =  AltCLIPVisionConfig(**SCREAMING_SNAKE_CASE__							).to_dict()
                   # convert keys to string instead of integer
                   if "id2label" in _vision_config_dict:
                         __SCREAMING_SNAKE_CASE       :Any		    =  {
                             str(SCREAMING_SNAKE_CASE__							): value for key, value in _vision_config_dict['''id2label'''].items()
                         }

                   # Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
                   for key, value in _vision_config_dict.items():
                         if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
                               # If specified in `vision_config_dict`
                               if key in vision_config_dict:
                                     __SCREAMING_SNAKE_CASE       :str		    =  (
                                         f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
                                         f'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
                                     )
                               # If inferred from default argument values (just to be super careful)
                               else:
                                     __SCREAMING_SNAKE_CASE       :Any		    =  (
                                         f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
                                         f'''The value `vision_config["{key}"]` will be overriden.'''
                                     )
                               logger.warning(SCREAMING_SNAKE_CASE__							)

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
                   vision_config.update(_vision_config_dict							)

             if text_config is None:
                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  {}
                   logger.info('''`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'''							)

             if vision_config is None:
                   __SCREAMING_SNAKE_CASE       :Tuple		    =  {}
                   logger.info('''`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'''							)

             __SCREAMING_SNAKE_CASE       :Any		    =  AltCLIPTextConfig(**SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  AltCLIPVisionConfig(**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  projection_dim
             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  logit_scale_init_value
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  1.0




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





             """simple docstring"""






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




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






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






"""simple docstring"""
def 					__lowerCamelCase       (							a_					:		int = 10			,       a_					:		int = 22							)      ->				int:
      __SCREAMING_SNAKE_CASE       :Optional[int]		    =  range(1			,       a_							)
      __SCREAMING_SNAKE_CASE       :List[Any]		    =  range(1			,       a_							)
      return sum(
          1 for power in powers for base in bases if len(str(base**power							)							) == power							)


if __name__ == "__main__":
  print(f'{solution(1_0, 2_2) = }')