
'''simple docstring'''







import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


lowercase					:							int   =      logging.get_logger(__name__)

lowercase					:							Optional[Any]   =      {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

lowercase					:							Union[str, Any]   =      {
    "vocab_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt"
        ),
        "squeezebert/squeezebert-mnli": "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt",
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli": (
            "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json"
        ),
    },
}

lowercase					:							Optional[Any]   =      {
    "squeezebert/squeezebert-uncased": 512,
    "squeezebert/squeezebert-mnli": 512,
    "squeezebert/squeezebert-mnli-headless": 512,
}


lowercase					:							Dict   =      {
    "squeezebert/squeezebert-uncased": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli-headless": {"do_lower_case": True},
}


class 		__UpperCAmelCase   (      _lowerCamelCase		):
							__lowercase   	= VOCAB_FILES_NAMES
							__lowercase   	= PRETRAINED_VOCAB_FILES_MAP
							__lowercase   	= PRETRAINED_INIT_CONFIGURATION
							__lowercase   	= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__lowercase   	= SqueezeBertTokenizer


							def __init__( self					,     lowerCAmelCase_=None					,     lowerCAmelCase_=None					,     lowerCAmelCase_=True					,     lowerCAmelCase_="[UNK]"					,     lowerCAmelCase_="[SEP]"					,     lowerCAmelCase_="[PAD]"					,     lowerCAmelCase_="[CLS]"					,     lowerCAmelCase_="[MASK]"					,     lowerCAmelCase_=True					,     lowerCAmelCase_=None					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								super().__init__(
								    lowerCAmelCase_					,     tokenizer_file=lowerCAmelCase_					,     do_lower_case=lowerCAmelCase_					,     unk_token=lowerCAmelCase_					,     sep_token=lowerCAmelCase_					,     pad_token=lowerCAmelCase_					,     cls_token=lowerCAmelCase_					,     mask_token=lowerCAmelCase_					,     tokenize_chinese_chars=lowerCAmelCase_					,     strip_accents=lowerCAmelCase_					,     **lowerCAmelCase_					,     )

								_snake_case     		=	json.loads(self.backend_tokenizer.normalizer.__getstate__()						)
								if (
								    normalizer_state.get('lowercase'					,     lowerCAmelCase_						) != do_lower_case
								    or normalizer_state.get('strip_accents'					,     lowerCAmelCase_						) != strip_accents
								    or normalizer_state.get('handle_chinese_chars'					,     lowerCAmelCase_						) != tokenize_chinese_chars
								):
									_snake_case     		=	getattr(lowerCAmelCase_					,     normalizer_state.pop('type'						)						)
									_snake_case     		=	do_lower_case
									_snake_case     		=	strip_accents
									_snake_case     		=	tokenize_chinese_chars
									_snake_case     		=	normalizer_class(**lowerCAmelCase_						)

								_snake_case     		=	do_lower_case


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_=None						):





								"""simple docstring"""






								_snake_case     		=	[self.cls_token_id] + token_ids_a + [self.sep_token_id]

								if token_ids_a:
									output += token_ids_a + [self.sep_token_id]

								return output


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	[self.sep_token_id]
								_snake_case     		=	[self.cls_token_id]
								if token_ids_a is None:
									return len(cls + token_ids_a + sep						) * [0]
								return len(cls + token_ids_a + sep						) * [0] + len(token_ids_a + sep						) * [1]




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	self._tokenizer.model.save(lowerCAmelCase_					,     name=lowerCAmelCase_						)
								return tuple(lowerCAmelCase_						)



'''simple docstring'''







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 		__UpperCAmelCase   :


												@staticmethod
												def 				lowerCamelCase       ( *lowerCAmelCase_					,     **lowerCAmelCase_						):





													"""simple docstring"""






													pass


@is_pipeline_test
@require_vision
@require_torch
class 		__UpperCAmelCase   (      unittest.TestCase		):
							__lowercase   	= MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






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

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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	object_detector(examples[0]					,     threshold=0.0						)

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


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





								"""simple docstring"""






								pass


							@require_torch
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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

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

								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								        {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								    ]					,     )

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

								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        [
								            {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								            {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								            {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        ]
								    ]					,     )


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								        {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								        {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								    ]					,     )

								_snake_case     		=	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(lowerCAmelCase_					,     decimals=4						)					,     [
								        [
								            {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								        [
								            {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								    ]					,     )


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





								"""simple docstring"""






								pass


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	0.2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     threshold=lowerCAmelCase_					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								    ]					,     )




							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     top_k=lowerCAmelCase_					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								    ]					,     )

