



import unittest

from transformers import is_vision_available
from transformers.pipelines import 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 				_snake_case			:




											@staticmethod
											def 							A__      (						*__lowercase					:						List[str],					**__lowercase					:						int						):
														pass
@is_pipeline_test
@require_vision
class 				_snake_case			(					unittest.TestCase):




				@require_torch
				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				pipeline(
							    model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification",					)
							lowercase__					  =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
							lowercase__					  =				image_classifier(__lowercase,					candidate_labels=["a", "b", "c"]						)

							# The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
							# python and torch versions.
							self.assertIn(
							    nested_simplify(__lowercase						),					[
							        [{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "b"}, {"score": 0.333, "label": "c"}],
							        [{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "c"}, {"score": 0.333, "label": "b"}],
							    ],					)

							lowercase__					  =				image_classifier([image] * 5,					candidate_labels=["A", "B", "C"],					batch_size=2						)
							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							    ],					)




				@require_tf
				def 							A__      (						self					:						Any						):
							lowercase__					  =				pipeline(
							    model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification",					framework="tf"						)
							lowercase__					  =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
							lowercase__					  =				image_classifier(__lowercase,					candidate_labels=["a", "b", "c"]						)

							self.assertEqual(
							    nested_simplify(__lowercase						),					[{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "b"}, {"score": 0.333, "label": "c"}],					)

							lowercase__					  =				image_classifier([image] * 5,					candidate_labels=["A", "B", "C"],					batch_size=2						)
							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							        [
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							            {"score": 0.333, "label": ANY(__lowercase						)},
							        ],
							    ],					)




				@slow
				@require_torch
				def 							A__      (						self					:						int						):
							lowercase__					  =				pipeline(
							    task="zero-shot-image-classification",					model="openai/clip-vit-base-patch32",					)
							# This is an image of 2 cats with remotes and no planes
							lowercase__					  =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
							lowercase__					  =				image_classifier(__lowercase,					candidate_labels=["cat", "plane", "remote"]						)

							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        {"score": 0.511, "label": "remote"},
							        {"score": 0.485, "label": "cat"},
							        {"score": 0.004, "label": "plane"},
							    ],					)

							lowercase__					  =				image_classifier([image] * 5,					candidate_labels=["cat", "plane", "remote"],					batch_size=2						)
							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        [
							            {"score": 0.511, "label": "remote"},
							            {"score": 0.485, "label": "cat"},
							            {"score": 0.004, "label": "plane"},
							        ],
							    ]
							    * 5,					)




				@slow
				@require_tf
				def 							A__      (						self					:						List[Any]						):
							lowercase__					  =				pipeline(
							    task="zero-shot-image-classification",					model="openai/clip-vit-base-patch32",					framework="tf"						)
							# This is an image of 2 cats with remotes and no planes
							lowercase__					  =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
							lowercase__					  =				image_classifier(__lowercase,					candidate_labels=["cat", "plane", "remote"]						)
							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        {"score": 0.511, "label": "remote"},
							        {"score": 0.485, "label": "cat"},
							        {"score": 0.004, "label": "plane"},
							    ],					)

							lowercase__					  =				image_classifier([image] * 5,					candidate_labels=["cat", "plane", "remote"],					batch_size=2						)
							self.assertEqual(
							    nested_simplify(__lowercase						),					[
							        [
							            {"score": 0.511, "label": "remote"},
							            {"score": 0.485, "label": "cat"},
							            {"score": 0.004, "label": "plane"},
							        ],
							    ]
							    * 5,					)









import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing
class 				_snake_case			(					lowercase__):




				def __init__(						self					:						Optional[Any],					__lowercase					:						str = "▁",					__lowercase					:						bool = True,					__lowercase					:						Union[str, AddedToken] = "<unk>",					__lowercase					:						Union[str, AddedToken] = "</s>",					__lowercase					:						Union[str, AddedToken] = "<pad>",					):
							lowercase__					  =				{
							    "pad": {"id": 0, "token": pad_token},
							    "eos": {"id": 1, "token": eos_token},
							    "unk": {"id": 2, "token": unk_token},
							}

							lowercase__					  =				[None] * len(self.special_tokens						)
							for token_dict in self.special_tokens.values():
										lowercase__					  =				token_dict["token"]

							lowercase__					  =				Tokenizer(Unigram()						)

							lowercase__					  =				normalizers.Sequence(
							    [
							        normalizers.Nmt(),
							        normalizers.NFKC(),
							        normalizers.Replace(Regex(" {2,}"						),					" "						),
							        normalizers.Lowercase(),
							    ]						)
							lowercase__					  =				pre_tokenizers.Sequence(
							    [
							        pre_tokenizers.Metaspace(replacement=__lowercase,					add_prefix_space=__lowercase						),
							        pre_tokenizers.Digits(individual_digits=__lowercase						),
							        pre_tokenizers.Punctuation(),
							    ]						)
							lowercase__					  =				decoders.Metaspace(replacement=__lowercase,					add_prefix_space=__lowercase						)

							lowercase__					  =				TemplateProcessing(
							    single=F'''$A {self.special_tokens["eos"]["token"]}''',					special_tokens=[(self.special_tokens["eos"]["token"], self.special_tokens["eos"]["id"])],					)

							lowercase__					  =				{
							    "model": "SentencePieceUnigram",
							    "replacement": replacement,
							    "add_prefix_space": add_prefix_space,
							}

							super().__init__(__lowercase,					__lowercase						)




				def 							A__      (						self					:						Union[str, Any],					__lowercase					:						Union[str, List[str]],					__lowercase					:						int = 8000,					__lowercase					:						bool = True,					):
							lowercase__					  =				trainers.UnigramTrainer(
							    vocab_size=__lowercase,					special_tokens=self.special_tokens_list,					show_progress=__lowercase,					)

							if isinstance(__lowercase,					__lowercase						):
										lowercase__					  =				[files]
							self._tokenizer.train(__lowercase,					trainer=__lowercase						)

							self.add_unk_id()




				def 							A__      (						self					:						List[Any],					__lowercase					:						Union[Iterator[str], Iterator[Iterator[str]]],					__lowercase					:						int = 8000,					__lowercase					:						bool = True,					):
							lowercase__					  =				trainers.UnigramTrainer(
							    vocab_size=__lowercase,					special_tokens=self.special_tokens_list,					show_progress=__lowercase,					)

							self._tokenizer.train_from_iterator(__lowercase,					trainer=__lowercase						)

							self.add_unk_id()




				def 							A__      (						self					:						str						):
							lowercase__					  =				json.loads(self._tokenizer.to_str()						)

							lowercase__					  =				self.special_tokens["unk"]["id"]

							lowercase__					  =				Tokenizer.from_str(json.dumps(__lowercase						)						)




