"""simple docstring"""
import copy
import os
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union


if TYPE_CHECKING:
					from ...processing_utils import ProcessorMixin
					from ...utils import TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      						=  {
    "google/owlvit-base-patch32": "https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json",
    "google/owlvit-base-patch16": "https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json",
    "google/owlvit-large-patch14": "https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json",
}



class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Union[str, Any]			  =						"""owlvit_text_model"""

				def __init__(				self		,    lowerCAmelCase=4_94_08		,    lowerCAmelCase=5_12		,    lowerCAmelCase=20_48		,    lowerCAmelCase=12		,    lowerCAmelCase=8		,    lowerCAmelCase=16		,    lowerCAmelCase="quick_gelu"		,    lowerCAmelCase=1E-5		,    lowerCAmelCase=0.0		,    lowerCAmelCase=0.02		,    lowerCAmelCase=1.0		,    lowerCAmelCase=0		,    lowerCAmelCase=4_94_06		,    lowerCAmelCase=4_94_07		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

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

										snake_case								=			vocab_size
										snake_case								=			hidden_size
										snake_case								=			intermediate_size
										snake_case								=			num_hidden_layers
										snake_case								=			num_attention_heads
										snake_case								=			max_position_embeddings
										snake_case								=			hidden_act
										snake_case								=			layer_norm_eps
										snake_case								=			attention_dropout
										snake_case								=			initializer_range
										snake_case								=			initializer_factor

				@classmethod
				def 		snake_case (				cls		,    lowerCAmelCase		,    **lowerCAmelCase    ):






										"""simple docstring"""

										cls._set_token_in_kwargs(lowerCAmelCase    )

										snake_case					,snake_case								=			cls.get_config_dict(lowerCAmelCase		,    **lowerCAmelCase    )

										# get the text config dict if we are loading from OwlViTConfig
										if config_dict.get('model_type'    ) == "owlvit":
																snake_case								=			config_dict['text_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(lowerCAmelCase		,    **lowerCAmelCase    )





class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Optional[Any]			  =						"""owlvit_vision_model"""

				def __init__(				self		,    lowerCAmelCase=7_68		,    lowerCAmelCase=30_72		,    lowerCAmelCase=12		,    lowerCAmelCase=12		,    lowerCAmelCase=3		,    lowerCAmelCase=7_68		,    lowerCAmelCase=32		,    lowerCAmelCase="quick_gelu"		,    lowerCAmelCase=1E-5		,    lowerCAmelCase=0.0		,    lowerCAmelCase=0.02		,    lowerCAmelCase=1.0		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

										super().__init__(**lowerCAmelCase    )

										snake_case								=			hidden_size
										snake_case								=			intermediate_size
										snake_case								=			num_hidden_layers
										snake_case								=			num_attention_heads
										snake_case								=			num_channels
										snake_case								=			image_size
										snake_case								=			patch_size
										snake_case								=			hidden_act
										snake_case								=			layer_norm_eps
										snake_case								=			attention_dropout
										snake_case								=			initializer_range
										snake_case								=			initializer_factor

				@classmethod
				def 		snake_case (				cls		,    lowerCAmelCase		,    **lowerCAmelCase    ):






										"""simple docstring"""

										cls._set_token_in_kwargs(lowerCAmelCase    )

										snake_case					,snake_case								=			cls.get_config_dict(lowerCAmelCase		,    **lowerCAmelCase    )

										# get the vision config dict if we are loading from OwlViTConfig
										if config_dict.get('model_type'    ) == "owlvit":
																snake_case								=			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(lowerCAmelCase		,    **lowerCAmelCase    )





class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Union[str, Any]			  =						"""owlvit"""
				_lowerCAmelCase     :    Union[str, Any]			  =						True

				def __init__(				self		,    lowerCAmelCase=None		,    lowerCAmelCase=None		,    lowerCAmelCase=5_12		,    lowerCAmelCase=2.65_92		,    lowerCAmelCase=True		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

										super().__init__(**lowerCAmelCase    )

										if text_config is None:
																snake_case								=			{}
																logger.info('text_config is None. Initializing the OwlViTTextConfig with default values.'    )

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

										snake_case								=			OwlViTTextConfig(**lowerCAmelCase    )
										snake_case								=			OwlViTVisionConfig(**lowerCAmelCase    )

										snake_case								=			projection_dim
										snake_case								=			logit_scale_init_value
										snake_case								=			return_dict
										snake_case								=			1.0

				@classmethod
				def 		snake_case (				cls		,    lowerCAmelCase		,    **lowerCAmelCase    ):






										"""simple docstring"""

										cls._set_token_in_kwargs(lowerCAmelCase    )

										snake_case					,snake_case								=			cls.get_config_dict(lowerCAmelCase		,    **lowerCAmelCase    )

										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(lowerCAmelCase		,    **lowerCAmelCase    )

				@classmethod
				def 		snake_case (				cls		,    lowerCAmelCase		,    lowerCAmelCase		,    **lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			{}
										snake_case								=			text_config
										snake_case								=			vision_config

										return cls.from_dict(lowerCAmelCase		,    **lowerCAmelCase    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			copy.deepcopy(self.__dict__    )
										snake_case								=			self.text_config.to_dict()
										snake_case								=			self.vision_config.to_dict()
										snake_case								=			self.__class__.model_type
										return output





class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""

				@property
				def 		snake_case (				self    ):






										"""simple docstring"""

										return OrderedDict(
										    [
										        ('input_ids', {0: 'batch', 1: 'sequence'}),
										        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
										        ('attention_mask', {0: 'batch', 1: 'sequence'}),
										    ]    )

				@property
				def 		snake_case (				self    ):






										"""simple docstring"""

										return OrderedDict(
										    [
										        ('logits_per_image', {0: 'batch'}),
										        ('logits_per_text', {0: 'batch'}),
										        ('text_embeds', {0: 'batch'}),
										        ('image_embeds', {0: 'batch'}),
										    ]    )

				@property
				def 		snake_case (				self    ):






										"""simple docstring"""

										return 1E-4

				def 		snake_case (				self		,    lowerCAmelCase		,    lowerCAmelCase = -1		,    lowerCAmelCase = -1		,    lowerCAmelCase = None		,    ):






										"""simple docstring"""

										snake_case								=			super().generate_dummy_inputs(
										    processor.tokenizer		,    batch_size=lowerCAmelCase		,    seq_length=lowerCAmelCase		,    framework=lowerCAmelCase    )
										snake_case								=			super().generate_dummy_inputs(
										    processor.image_processor		,    batch_size=lowerCAmelCase		,    framework=lowerCAmelCase    )
										return {**text_input_dict, **image_input_dict}

				@property
				def 		snake_case (				self    ):






										"""simple docstring"""

										return 14



"""simple docstring"""
import os
import string
import sys


SCREAMING_SNAKE_CASE__      						=  1 << 8

SCREAMING_SNAKE_CASE__      						=  {
    "tab": ord("\t"),
    "newline": ord("\r"),
    "esc": 27,
    "up": 65 + ARROW_KEY_FLAG,
    "down": 66 + ARROW_KEY_FLAG,
    "right": 67 + ARROW_KEY_FLAG,
    "left": 68 + ARROW_KEY_FLAG,
    "mod_int": 91,
    "undefined": sys.maxsize,
    "interrupt": 3,
    "insert": 50,
    "delete": 51,
    "pg_up": 53,
    "pg_down": 54,
}

SCREAMING_SNAKE_CASE__      						=  KEYMAP["up"]
SCREAMING_SNAKE_CASE__      						=  KEYMAP["left"]

if sys.platform == "win32":
					SCREAMING_SNAKE_CASE__      						=  []
					SCREAMING_SNAKE_CASE__      						=  {
					    b"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
					    b"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
					    b"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
					    b"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
					    b"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
					    b"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
					    b"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
					    b"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
					}

for i in range(10):
					SCREAMING_SNAKE_CASE__      						=  ord(str(i))





def    lowerCAmelCase__    (			)					->				List[Any]:





						"""simple docstring"""






						if os.name == "nt":
												import msvcrt

												snake_case								=			'mbcs'
												# Flush the keyboard buffer
												while msvcrt.kbhit():
																		msvcrt.getch()
												if len(_UpperCamelCase					) == 0:
																		# Read the keystroke
																		snake_case								=			msvcrt.getch()

																		# If it is a prefix char, get second part
																		if ch in (b"\x00", b"\xe0"):
																								snake_case								=			ch + msvcrt.getch()
																								# Translate actual Win chars to bullet char types
																								try:
																														snake_case								=			chr(WIN_KEYMAP[cha]					)
																														WIN_CH_BUFFER.append(chr(KEYMAP['mod_int']					)					)
																														WIN_CH_BUFFER.append(_UpperCamelCase					)
																														if ord(_UpperCamelCase					) in (
																														    KEYMAP["insert"] - 1 << 9,
																														    KEYMAP["delete"] - 1 << 9,
																														    KEYMAP["pg_up"] - 1 << 9,
																														    KEYMAP["pg_down"] - 1 << 9,
																														):
																																				WIN_CH_BUFFER.append(chr(1_2_6					)					)
																														snake_case								=			chr(KEYMAP['esc']					)
																								except KeyError:
																														snake_case								=			cha[1]
																		else:
																								snake_case								=			ch.decode(_UpperCamelCase					)
												else:
																		snake_case								=			WIN_CH_BUFFER.pop(0					)
						elif os.name == "posix":
												import termios
												import tty

												snake_case								=			sys.stdin.fileno()
												snake_case								=			termios.tcgetattr(_UpperCamelCase					)
												try:
																		tty.setraw(_UpperCamelCase					)
																		snake_case								=			sys.stdin.read(1					)
												finally:
																		termios.tcsetattr(_UpperCamelCase ,			termios.TCSADRAIN ,			_UpperCamelCase					)
						return ch





def    lowerCAmelCase__    (			)					->				Union[str, Any]:





						"""simple docstring"""






						snake_case								=			get_raw_chars()
						if ord(_UpperCamelCase					) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
												return char

						elif ord(_UpperCamelCase					) == KEYMAP["esc"]:
												snake_case								=			get_raw_chars()
												if ord(_UpperCamelCase					) == KEYMAP["mod_int"]:
																		snake_case								=			get_raw_chars()
																		if ord(_UpperCamelCase					) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(_UpperCamelCase					) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
																								return chr(ord(_UpperCamelCase					) + ARROW_KEY_FLAG					)
																		else:
																								return KEYMAP["undefined"]
												else:
																		return get_raw_chars()

						else:
												if char in string.printable:
																		return char
												else:
																		return KEYMAP["undefined"]


