from typing import Dict, List, Optional

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__UpperCamelCase		:       Dict									=     logging.get_logger(__name__)


__UpperCamelCase		:       int									=     {
    'nielsr/canine-s': 2048,
}

# Unicode defines 1,114,112 total “codepoints”
__UpperCamelCase		:       str									=     111_4112

# Below: Constants defining canonical codepoints for special, pseudo-characters.
# Copied from https://github.com/google-research/language/blob/master/language/canine/special_codepoints.py
__UpperCamelCase		:       Optional[int]									=     0

__UpperCamelCase		:       Optional[int]									=     0xe000
__UpperCamelCase		:       Union[str, Any]									=     0xe001
__UpperCamelCase		:       List[Any]									=     0xe002
__UpperCamelCase		:       Union[str, Any]									=     0xe003
__UpperCamelCase		:       List[Any]									=     0xe004

# Maps special codepoints to human-readable names.
__UpperCamelCase		:       Dict[int, str]									=     {
    # Special symbols are represented using codepoints values that are valid,
    # but designated as "Private Use", meaning that they will never be assigned
    # characters by the Unicode Consortium, and are thus safe for use here.
    #
    # NOTE: Do *NOT* add any sort of [UNK_CHAR] here. They are explicitly
    # excluded and should fail with a hard error.
    CLS: "[CLS]",
    SEP: "[SEP]",
    BOS: "[BOS]",
    MASK: "[MASK]",
    PAD: "[PAD]",
    RESERVED: "[RESERVED]",
}

# Maps special codepoint human-readable names to their codepoint values.
__UpperCamelCase		:       Dict[str, int]									=     {name: codepoint for codepoint, name in SPECIAL_CODEPOINTS.items()}





class 					lowercase__						(   UpperCamelCase_):
						UpperCamelCase_     =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES


						def __init__(       self	:				List[Any]    ,		UpperCamelCase__	:				int=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				List[str]=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				List[str]=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				Union[str, Any]=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				str=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				Any=chr(UpperCamelCase__						)    ,		UpperCamelCase__	:				Tuple=False    ,		UpperCamelCase__	:				int=2048    ,		**UpperCamelCase__	:				List[str]    ,		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Dict							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else bos_token
												SCREAMING_SNAKE_CASE							:    List[str]							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else eos_token
												SCREAMING_SNAKE_CASE							:    Tuple							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else sep_token
												SCREAMING_SNAKE_CASE							:    int							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else cls_token
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else pad_token

												# Mask token behave like a normal word, i.e. include the space before it
												SCREAMING_SNAKE_CASE							:    List[str]							=							AddedToken(UpperCamelCase__    ,		lstrip=UpperCamelCase__    ,		rstrip=UpperCamelCase__						) if isinstance(UpperCamelCase__    ,		UpperCamelCase__						) else mask_token

												super().__init__(
												    bos_token=UpperCamelCase__    ,		eos_token=UpperCamelCase__    ,		sep_token=UpperCamelCase__    ,		cls_token=UpperCamelCase__    ,		pad_token=UpperCamelCase__    ,		mask_token=UpperCamelCase__    ,		add_prefix_space=UpperCamelCase__    ,		model_max_length=UpperCamelCase__    ,		**UpperCamelCase__    ,		)

												# Creates a mapping for looking up the IDs of special symbols.
												SCREAMING_SNAKE_CASE							:    Dict[str, int]							=							{}
												for codepoint, name in SPECIAL_CODEPOINTS.items():
																		SCREAMING_SNAKE_CASE							:    str							=							codepoint

												# Creates a mapping for looking up the string forms of special symbol IDs.
												SCREAMING_SNAKE_CASE							:    Dict[int, str]							=							{
												    codepoint: name for name, codepoint in self._special_codepoints.items()
												}

												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							UNICODE_VOCAB_SIZE
												SCREAMING_SNAKE_CASE							:    Tuple							=							len(self._special_codepoints						)


						@property
						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												return self._unicode_vocab_size


						def        __A       (       self	:				Optional[Any]    ,		UpperCamelCase__	:				str						):





												'''simple docstring'''





												return list(UpperCamelCase__						)


						def        __A       (       self	:				Tuple    ,		UpperCamelCase__	:				str						):





												'''simple docstring'''





												try:
																		return ord(UpperCamelCase__						)
												except TypeError:
																		raise ValueError(f"""invalid token: '{token}'"""						)


						def        __A       (       self	:				List[Any]    ,		UpperCamelCase__	:				int						):





												'''simple docstring'''





												try:
																		if index in SPECIAL_CODEPOINTS:
																								return SPECIAL_CODEPOINTS[index]
																		return chr(UpperCamelCase__						)
												except TypeError:
																		raise ValueError(f"""invalid id: {index}"""						)


						def        __A       (       self	:				int    ,		UpperCamelCase__	:				Optional[Any]						):





												'''simple docstring'''





												return "".join(UpperCamelCase__						)


						def        __A       (       self	:				Optional[int]    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Dict							=							[self.sep_token_id]
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							[self.cls_token_id]

												SCREAMING_SNAKE_CASE							:    Optional[int]							=							cls + token_ids_a + sep
												if token_ids_a is not None:
																		result += token_ids_a + sep
												return result


						def        __A       (       self	:				Optional[int]    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None    ,		UpperCamelCase__	:				bool = False						):





												'''simple docstring'''





												if already_has_special_tokens:
																		return super().get_special_tokens_mask(
																		    token_ids_a=UpperCamelCase__    ,		token_ids_a=UpperCamelCase__    ,		already_has_special_tokens=UpperCamelCase__						)

												SCREAMING_SNAKE_CASE							:    Dict							=							[1] + ([0] * len(UpperCamelCase__						)) + [1]
												if token_ids_a is not None:
																		result += ([0] * len(UpperCamelCase__						)) + [1]
												return result


						def        __A       (       self	:				Dict    ,		UpperCamelCase__	:				List[int]    ,		UpperCamelCase__	:				Optional[List[int]] = None						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							[self.sep_token_id]
												SCREAMING_SNAKE_CASE							:    Any							=							[self.cls_token_id]

												SCREAMING_SNAKE_CASE							:    str							=							len(cls + token_ids_a + sep						) * [0]
												if token_ids_a is not None:
																		result += len(token_ids_a + sep						) * [1]
												return result



						def        __A       (       self	:				Tuple    ,		UpperCamelCase__	:				str    ,		UpperCamelCase__	:				Optional[str] = None						):





												'''simple docstring'''





												return ()






import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
					from PIL import Image
else:





					class 					lowercase__						:


											@staticmethod
											def        __A       (       *UpperCamelCase__	:				Union[str, Any]    ,		**UpperCamelCase__	:				Optional[Any]						):





																	'''simple docstring'''





																	pass





@is_pipeline_test
@require_vision
@require_torch
class 					lowercase__						(   unittest.TestCase):
						UpperCamelCase_     =		MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING


						def        __A       (       self	:				Union[str, Any]    ,		UpperCamelCase__	:				Tuple    ,		UpperCamelCase__	:				List[Any]    ,		UpperCamelCase__	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							pipeline(
												    '''zero-shot-object-detection'''    ,		model='''hf-internal-testing/tiny-random-owlvit-object-detection'''						)

												SCREAMING_SNAKE_CASE							:    List[str]							=							[
												    {
												        '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
												        '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												    }
												]
												return object_detector, examples


						def        __A       (       self	:				Union[str, Any]    ,		UpperCamelCase__	:				Any    ,		UpperCamelCase__	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							object_detector(examples[0]    ,		threshold=0.0						)

												SCREAMING_SNAKE_CASE							:    Tuple							=							len(UpperCamelCase__						)
												self.assertGreater(UpperCamelCase__    ,		0						)
												self.assertEqual(
												    UpperCamelCase__    ,		[
												        {
												            '''score''': ANY(UpperCamelCase__						),
												            '''label''': ANY(UpperCamelCase__						),
												            '''box''': {'''xmin''': ANY(UpperCamelCase__						), '''ymin''': ANY(UpperCamelCase__						), '''xmax''': ANY(UpperCamelCase__						), '''ymax''': ANY(UpperCamelCase__						)},
												        }
												        for i in range(UpperCamelCase__						)
												    ]    ,		)


						@require_tf
						@unittest.skip('''Zero Shot Object Detection not implemented in TF'''						)
						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												pass


						@require_torch
						def        __A       (       self	:				Dict						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Tuple							=							pipeline(
												    '''zero-shot-object-detection'''    ,		model='''hf-internal-testing/tiny-random-owlvit-object-detection'''						)

												SCREAMING_SNAKE_CASE							:    str							=							object_detector(
												    '''./tests/fixtures/tests_samples/COCO/000000039769.png'''    ,		candidate_labels=['''cat''', '''remote''', '''couch''']    ,		threshold=0.64    ,		)

												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												        {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
												        {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												    ]    ,		)

												SCREAMING_SNAKE_CASE							:    str							=							object_detector(
												    [
												        {
												            '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        }
												    ]    ,		threshold=0.64    ,		)

												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        [
												            {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												            {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
												            {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												        ]
												    ]    ,		)


						@require_torch
						@slow
						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    int							=							pipeline('''zero-shot-object-detection'''						)

												SCREAMING_SNAKE_CASE							:    Optional[int]							=							object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg'''    ,		candidate_labels=['''cat''', '''remote''', '''couch''']    ,		)
												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												        {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												        {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												        {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												    ]    ,		)

												SCREAMING_SNAKE_CASE							:    int							=							object_detector(
												    [
												        {
												            '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        },
												        {
												            '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        },
												    ]    ,		)
												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        [
												            {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												            {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												            {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												            {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												            {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												        ],
												        [
												            {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												            {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												            {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												            {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												            {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												        ],
												    ]    ,		)


						@require_tf
						@unittest.skip('''Zero Shot Object Detection not implemented in TF'''						)
						def        __A       (       self	:				str						):





												'''simple docstring'''





												pass


						@require_torch
						@slow
						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Tuple							=							0.2
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							pipeline('''zero-shot-object-detection'''						)

												SCREAMING_SNAKE_CASE							:    Dict							=							object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg'''    ,		candidate_labels=['''cat''', '''remote''', '''couch''']    ,		threshold=UpperCamelCase__    ,		)
												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												        {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												    ]    ,		)



						@require_torch
						@slow
						def        __A       (       self	:				List[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							2
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							pipeline('''zero-shot-object-detection'''						)

												SCREAMING_SNAKE_CASE							:    List[str]							=							object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg'''    ,		candidate_labels=['''cat''', '''remote''', '''couch''']    ,		top_k=UpperCamelCase__    ,		)
												self.assertEqual(
												    nested_simplify(UpperCamelCase__    ,		decimals=4						)    ,		[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												    ]    ,		)





