code: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  from math import sqrt
  def _A		(		lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=[1]
      for i in range(2 ,					int(sqrt(lowercase	)	) + 1 ,					1	):
          if number % i == 0:
              values.append(lowercase	)
              if int(number // i	) != i:
                  values.append(int(number // i	)	)
      return sorted(lowercase	)
  def _A		(		lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      return sum(factors(lowercase	)	) > n
  def _A		(		lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=factors(lowercase	)
      a					=len(lowercase	)
      a					=[[0 for i in range(number + 1	)] for j in range(r + 1	)]
      for i in range(r + 1	):
          a					=True
  
      for i in range(1 ,					number + 1	):
          a					=False
  
      for i in range(1 ,					r + 1	):
          for j in range(1 ,					number + 1	):
              if j < values[i - 1]:
                  a					=subset[i - 1][j]
              else:
                  a					=subset[i - 1][j] or subset[i - 1][j - values[i - 1]]
  
      return subset[r][number] != 0
  def _A		(		lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      return abundant(lowercase	) and not semi_perfect(lowercase	)
  
  
  if __name__ == "__main__":
         import doctest
  
         doctest.testmod(verbose=True)
         for number in (6_9, 7_0, 7_1):
                print(F'{number} is {"" if weird(number) else "not "}weird.')
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import copy
  
  from transformers.configuration_utils import PretrainedConfig
  from transformers.utils import logging
  
  
  lowerCamelCase_     :     int    		=						logging.get_logger(__name__)
  
  
  
  
  
  
  class    __A       ( _SCREAMING_SNAKE_CASE    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						"hybrid-clip"
   __lowerCAmelCase				      =						True
  
  
   def __init__(	self				,					__A=512				,					**__A		)      ->  Any:
       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`.'''		)
  
       a					=kwargs.pop('''text_config'''		)
       a					=kwargs.pop('''vision_config'''		)
  
       a					=text_config.pop('''model_type'''		)
       a					=vision_config.pop('''model_type'''		)
  
       from transformers import AutoConfig
  
       a					=AutoConfig.for_model(__A				,					**__A		)
  
       if vision_model_type == "clip":
           a					=AutoConfig.for_model(__A				,					**__A		).vision_config
       elif vision_model_type == "clip_vision_model":
           from transformers import CLIPVisionConfig
  
           a					=CLIPVisionConfig(**__A		)
       else:
           a					=AutoConfig.for_model(__A				,					**__A		)
  
       a					=projection_dim
       a					=1.0
  
  
   @classmethod
   def    SCREAMING_SNAKE_CASE							(	cls				,					__A				,					__A				,					**__A		)      ->  Tuple:
       return cls(text_config=text_config.to_dict()				,					vision_config=vision_config.to_dict()				,					**__A		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[int]:
       a					=copy.deepcopy(self.__dict__		)
       a					=self.text_config.to_dict()
       a					=self.vision_config.to_dict()
       a					=self.__class__.model_type
       return output