



'''simple docstring'''

from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
							from PIL import Image

							from ..image_utils import load_image

if is_torch_available():
							import torch

							from transformers.modeling_outputs import BaseModelOutput

							from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

__lowerCAmelCase		     =  logging.get_logger(__name__)

@add_end_docstrings(_UpperCamelCase  )
class       __magic_name__		(       _UpperCamelCase  ):







							def __init__(				self   :			List[Any]      ,**_UpperCAmelCase   :			Optional[int]						):
									super().__init__(**_UpperCAmelCase						)

									if self.framework == "tf":
											raise ValueError(F"""The {self.__class__} is only available in PyTorch."""						)

									requires_backends(self      ,'vision'						)
									self.check_model_type(_UpperCAmelCase						)







							def __call__(				self   :			Tuple      ,_UpperCAmelCase   :			Union[str, "Image.Image", List[Dict[str, Any]]]      ,_UpperCAmelCase   :			Union[str, List[str]] = None      ,**_UpperCAmelCase   :			Union[str, Any]      ,):
									if "text_queries" in kwargs:
											_a	: List[str]								=				kwargs.pop('text_queries'						)

									if isinstance(_UpperCAmelCase      ,(str, Image.Image)						):
											_a	: Optional[Any]								=				{'image': image, 'candidate_labels': candidate_labels}
									else:
											_a	: Any								=				image
									_a	: Tuple								=				super().__call__(_UpperCAmelCase      ,**_UpperCAmelCase						)
									return results







							def 				__lowercase     (				self   :			Optional[int]      ,**_UpperCAmelCase   :			Optional[int]						):
									_a	: List[Any]								=				{}
									if "threshold" in kwargs:
											_a	: Optional[Any]								=				kwargs['threshold']
									if "top_k" in kwargs:
											_a	: List[Any]								=				kwargs['top_k']
									return {}, {}, postprocess_params







							def 				__lowercase     (				self   :			Tuple      ,_UpperCAmelCase   :			str						):
									_a	: str								=				load_image(inputs['image']						)
									_a	: Optional[int]								=				inputs['candidate_labels']
									if isinstance(_UpperCAmelCase      ,_UpperCAmelCase						):
											_a	: str								=				candidate_labels.split(','						)

									_a	: int								=				torch.tensor([[image.height, image.width]]      ,dtype=torch.intaa						)
									for i, candidate_label in enumerate(_UpperCAmelCase						):
											_a	: Optional[int]								=				self.tokenizer(_UpperCAmelCase      ,return_tensors=self.framework						)
											_a	: Union[str, Any]								=				self.image_processor(_UpperCAmelCase      ,return_tensors=self.framework						)
											yield {
											    "is_last": i == len(_UpperCAmelCase						) - 1,
											    "target_size": target_size,
											    "candidate_label": candidate_label,
											    **text_inputs,
											    **image_features,
											}







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			Dict						):
									_a	: Tuple								=				model_inputs.pop('target_size'						)
									_a	: Tuple								=				model_inputs.pop('candidate_label'						)
									_a	: int								=				model_inputs.pop('is_last'						)

									_a	: List[str]								=				self.model(**_UpperCAmelCase						)

									_a	: List[Any]								=				{'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs}
									return model_outputs







							def 				__lowercase     (				self   :			Dict      ,_UpperCAmelCase   :			List[str]      ,_UpperCAmelCase   :			List[str]=0.1      ,_UpperCAmelCase   :			Tuple=None						):
									_a	: Tuple								=				[]
									for model_output in model_outputs:
											_a	: Optional[int]								=				model_output['candidate_label']
											_a	: Optional[int]								=				BaseModelOutput(_UpperCAmelCase						)
											_a	: Dict								=				self.image_processor.post_process_object_detection(
											    outputs=_UpperCAmelCase      ,threshold=_UpperCAmelCase      ,target_sizes=model_output['target_size']						)[0]

											for index in outputs["scores"].nonzero():
													_a	: Any								=				outputs['scores'][index].item()
													_a	: Union[str, Any]								=				self._get_bounding_box(outputs['boxes'][index][0]						)

													_a	: Optional[Any]								=				{'score': score, 'label': label, 'box': box}
													results.append(_UpperCAmelCase						)

									_a	: Dict								=				sorted(_UpperCAmelCase      ,key=lambda _UpperCAmelCase						: x["score"]      ,reverse=_UpperCAmelCase						)
									if top_k:
											_a	: Tuple								=				results[:top_k]

									return results







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			"torch.Tensor"						):
									if self.framework != "pt":
											raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.'						)
									_a			,   _a			,   _a			,   _a	: List[Any]								=				box.int().tolist()
									_a	: Any								=				{
									    'xmin': xmin,
									    'ymin': ymin,
									    'xmax': xmax,
									    'ymax': ymax,
									}
									return bbox









'''simple docstring'''

import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__lowerCAmelCase		     =  get_tests_dir('''fixtures/test_sentencepiece_with_bytefallback.model''')

@require_sentencepiece
@require_tokenizers
class       __magic_name__		(       _UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       Tuple  							=   GPTSwaTokenizer
							lowerCAmelCase			:       Tuple  							=   False
							lowerCAmelCase			:       Optional[Any]  							=   True
							lowerCAmelCase			:       Any  							=   False







							def 				__lowercase     (				self   :			Any						):
									super().setUp()

									# We have a SentencePiece fixture for testing
									_a	: int								=				GPTSwaTokenizer(_UpperCAmelCase      ,eos_token='<unk>'      ,bos_token='<unk>'      ,pad_token='<unk>'						)

									tokenizer.save_pretrained(self.tmpdirname						)







							def 				__lowercase     (				self   :			Optional[Any]      ,_UpperCAmelCase   :			int						):
									_a	: Any								=				'This is a test'
									_a	: Any								=				'This is a test'
									return input_text, output_text







							def 				__lowercase     (				self   :			str						):
									_a	: Optional[Any]								=				'<s>'
									_a	: str								=				1

									self.assertEqual(self.get_tokenizer()._convert_token_to_id(_UpperCAmelCase						)      ,_UpperCAmelCase						)
									self.assertEqual(self.get_tokenizer()._convert_id_to_token(_UpperCAmelCase						)      ,_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Union[str, Any]						):
									_a	: Dict								=				list(self.get_tokenizer().get_vocab().keys()						)

									self.assertEqual(vocab_keys[0]      ,'<unk>'						)
									self.assertEqual(vocab_keys[1]      ,'<s>'						)
									self.assertEqual(vocab_keys[-1]      ,'j'						)
									self.assertEqual(len(_UpperCAmelCase						)      ,2000						)







							def 				__lowercase     (				self   :			Optional[int]						):
									self.assertEqual(self.get_tokenizer().vocab_size      ,2000						)







							def 				__lowercase     (				self   :			List[Any]						):
									_a	: Union[str, Any]								=				GPTSwaTokenizer(_UpperCAmelCase						)

									_a	: str								=				tokenizer.tokenize('This is a test'						)
									self.assertListEqual(_UpperCAmelCase      ,['▁This', '▁is', '▁a', '▁t', 'est']						)

									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase						)      ,[465, 287, 265, 631, 842]						)

									_a	: Any								=				tokenizer.tokenize('I was born in 92000, and this is falsé.'						)
									# fmt: off
									self.assertListEqual(
									    _UpperCAmelCase      ,['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']      ,)
									# fmt: on

									_a	: Optional[Any]								=				tokenizer.convert_tokens_to_ids(_UpperCAmelCase						)
									self.assertListEqual(
									    _UpperCAmelCase      ,[262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260]      ,)

									_a	: List[str]								=				tokenizer.convert_ids_to_tokens(_UpperCAmelCase						)
									# fmt: off
									self.assertListEqual(
									    _UpperCAmelCase      ,['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']						)
									# fmt: on







							def 				__lowercase     (				self   :			str						):
									_a	: List[Any]								=				GPTSwaTokenizer(_UpperCAmelCase						)
									_a	: Optional[Any]								=				['This is a test', 'I was born in 92000, and this is falsé.']
									_a	: Dict								=				[
									    [465, 287, 265, 631, 842],
									    [262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260],
									]

									# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
									for text, expected_ids in zip(_UpperCAmelCase      ,_UpperCAmelCase						):
											self.assertListEqual(tokenizer.encode_fast(_UpperCAmelCase						)      ,_UpperCAmelCase						)

									# Test that decode_fast returns the input text
									for text, token_ids in zip(_UpperCAmelCase      ,_UpperCAmelCase						):
											self.assertEqual(tokenizer.decode_fast(_UpperCAmelCase						)      ,_UpperCAmelCase						)







							@slow
							def 				__lowercase     (				self   :			Optional[Any]						):
									_a	: Optional[int]								=				[
									    '<|python|>def fibonacci(n)\n    if n < 0:\n        print(\'Incorrect input\')',
									    'Hey there, how are you doing this fine day?',
									    'This is a text with a trailing spaces followed by a dot     .',
									    'Häj sväjs lillebrör! =)',
									    'Det är inget fel på Mr. Cool',
									]

									# fmt: off
									_a	: Tuple								=				{'input_ids': [[63423, 5, 6811, 14954, 282, 816, 3821, 63466, 63425, 63462, 18, 63978, 678, 301, 1320, 63423, 63455, 63458, 18, 63982, 4246, 3940, 1901, 47789, 5547, 18994], [19630, 1100, 63446, 1342, 633, 544, 4488, 593, 5102, 2416, 63495, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1652, 428, 268, 1936, 515, 268, 58593, 22413, 9106, 546, 268, 33213, 63979, 698, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [55130, 63450, 924, 63449, 2249, 4062, 1558, 318, 63504, 21498, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [509, 377, 2827, 2559, 332, 6575, 63443, 26801, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
									# fmt: on
									self.tokenizer_integration_test_util(
									    expected_encoding=_UpperCAmelCase      ,model_name='AI-Sweden/gpt-sw3-126m'      ,sequences=_UpperCAmelCase      ,)




