


import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


_A			=						logging.get_logger(__name__)

_A			=						{
    'salesforce/blip2-opt-2.7b': 'https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json',
}






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Tuple              =  "blip_2_vision_model"






    def __init__(      self ,       A_=1408 ,       A_=6144 ,       A_=39 ,       A_=16 ,       A_=224 ,       A_=14 ,       A_="gelu" ,       A_=0.0_0001 ,       A_=0.0 ,       A_=1E-10 ,       A_=True ,       **A_ ,       )  ->	Union[str, Any]:
         super().__init__(**A_   )

         __UpperCamelCase   							=hidden_size
         __UpperCamelCase   							=intermediate_size
         __UpperCamelCase   							=num_hidden_layers
         __UpperCamelCase   							=num_attention_heads
         __UpperCamelCase   							=patch_size
         __UpperCamelCase   							=image_size
         __UpperCamelCase   							=initializer_range
         __UpperCamelCase   							=attention_dropout
         __UpperCamelCase   							=layer_norm_eps
         __UpperCamelCase   							=hidden_act
         __UpperCamelCase   							=qkv_bias






    @classmethod
    def _a (      cls ,       A_ ,       **A_   )  ->	"PretrainedConfig":
         cls._set_token_in_kwargs(A_   )

         __UpperCamelCase							,				__UpperCamelCase   							=cls.get_config_dict(A_ ,       **A_   )

         # get the vision config dict if we are loading from Blip2Config
         if config_dict.get('model_type'   ) == "blip-2":
              __UpperCamelCase   							=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(A_ ,       **A_   )






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Any              =  "blip_2_qformer"






    def __init__(      self ,       A_=30522 ,       A_=768 ,       A_=12 ,       A_=12 ,       A_=3072 ,       A_="gelu" ,       A_=0.1 ,       A_=0.1 ,       A_=512 ,       A_=0.02 ,       A_=1E-12 ,       A_=0 ,       A_="absolute" ,       A_=2 ,       A_=1408 ,       **A_ ,       )  ->	List[str]:
         super().__init__(pad_token_id=A_ ,       **A_   )

         __UpperCamelCase   							=vocab_size
         __UpperCamelCase   							=hidden_size
         __UpperCamelCase   							=num_hidden_layers
         __UpperCamelCase   							=num_attention_heads
         __UpperCamelCase   							=hidden_act
         __UpperCamelCase   							=intermediate_size
         __UpperCamelCase   							=hidden_dropout_prob
         __UpperCamelCase   							=attention_probs_dropout_prob
         __UpperCamelCase   							=max_position_embeddings
         __UpperCamelCase   							=initializer_range
         __UpperCamelCase   							=layer_norm_eps
         __UpperCamelCase   							=position_embedding_type
         __UpperCamelCase   							=cross_attention_frequency
         __UpperCamelCase   							=encoder_hidden_size






    @classmethod
    def _a (      cls ,       A_ ,       **A_   )  ->	"PretrainedConfig":
         cls._set_token_in_kwargs(A_   )

         __UpperCamelCase							,				__UpperCamelCase   							=cls.get_config_dict(A_ ,       **A_   )

         # get the qformer config dict if we are loading from Blip2Config
         if config_dict.get('model_type'   ) == "blip-2":
              __UpperCamelCase   							=config_dict['qformer_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(A_ ,       **A_   )






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		List[Any]              =  "blip-2"
    UpperCAmelCase__						:		Optional[Any]              =  True






    def __init__(      self ,       A_=None ,       A_=None ,       A_=None ,       A_=32 ,       **A_   )  ->	Optional[int]:
         super().__init__(**A_   )

         if vision_config is None:
              __UpperCamelCase   							={}
              logger.info('vision_config is None. initializing the Blip2VisionConfig with default values.'   )

         if qformer_config is None:
              __UpperCamelCase   							={}
              logger.info('qformer_config is None. Initializing the Blip2QFormerConfig with default values.'   )

         if text_config is None:
              __UpperCamelCase   							={}
              logger.info('text_config is None. Initializing the text config with default values (`OPTConfig`).'   )

         __UpperCamelCase   							=BlipaVisionConfig(**A_   )
         __UpperCamelCase   							=BlipaQFormerConfig(**A_   )
         __UpperCamelCase   							=text_config['model_type'] if 'model_type' in text_config else 'opt'
         __UpperCamelCase   							=CONFIG_MAPPING[text_model_type](**A_   )

         __UpperCamelCase   							=self.text_config.tie_word_embeddings
         __UpperCamelCase   							=self.text_config.is_encoder_decoder

         __UpperCamelCase   							=num_query_tokens
         __UpperCamelCase   							=self.vision_config.hidden_size
         __UpperCamelCase   							=self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
         __UpperCamelCase   							=1.0
         __UpperCamelCase   							=0.02






    @classmethod
    def _a (      cls ,       A_ ,       A_ ,       A_ ,       **A_ ,       )  ->	List[str]:
         return cls(
             vision_config=vision_config.to_dict() ,       qformer_config=qformer_config.to_dict() ,       text_config=text_config.to_dict() ,       **A_ ,       )






    def _a (      self   )  ->	int:
         __UpperCamelCase   							=copy.deepcopy(self.__dict__   )
         __UpperCamelCase   							=self.vision_config.to_dict()
         __UpperCamelCase   							=self.qformer_config.to_dict()
         __UpperCamelCase   							=self.text_config.to_dict()
         __UpperCamelCase   							=self.__class__.model_type
         return output









import pprint

import requests

_A			=						'https://zenquotes.io/api'

def 						_UpperCAmelCase    (      ):
     return requests.get(API_ENDPOINT_URL + '/today'    ).json()

def 						_UpperCAmelCase    (      ):
     return requests.get(API_ENDPOINT_URL + '/random'    ).json()


if __name__ == "__main__":
   _A			=						random_quotes()
   pprint.pprint(response)





