code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import unittest
  
  from transformers import (
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      PreTrainedTokenizer,
      is_vision_available,
  )
  from transformers.pipelines import ImageClassificationPipeline, pipeline
  from transformers.testing_utils import (
      is_pipeline_test,
      nested_simplify,
      require_tf,
      require_torch,
      require_torch_or_tf,
      require_vision,
      slow,
  )
  
  from .test_pipelines_common import ANY
  
  
  if is_vision_available():
  						from PIL import Image
  else:
  
  
  
  
  
  						class   lowerCamelCase_							:
  
  
  
  
  											'''simple docstring'''
  
  
  
  
  
  
  											@staticmethod
  											def        __SCREAMING_SNAKE_CASE			(					*__UpperCamelCase,						**__UpperCamelCase				):
  													pass
  
  
  
  
  
  @is_pipeline_test
  @require_torch_or_tf
  @require_vision
  class   lowerCamelCase_							( unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  					lowercase__					=				TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase,						__UpperCamelCase				):
  							_snake_case			 =							ImageClassificationPipeline(model=__snake_case,						image_processor=__snake_case,						top_k=2				)
  							_snake_case			 =							[
  							    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				),
  							    "http://images.cocodataset.org/val2017/000000039769.jpg",
  							]
  							return image_classifier, examples
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase				):
  							_snake_case			 =							image_classifier("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
  
  							self.assertEqual(
  							    __snake_case,						[
  							        {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							    ],						)
  
  							import datasets
  
  							_snake_case			 =							datasets.load_dataset("hf-internal-testing/fixtures_image_utils",						"image",						split="test"				)
  
  							# Accepts URL + PIL.Image + lists
  							_snake_case			 =							image_classifier(
  							    [
  							        Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				),
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							        # RGBA
  							        dataset[0]["file"],
  							        # LA
  							        dataset[1]["file"],
  							        # L
  							        dataset[2]["file"],
  							    ]				)
  							self.assertEqual(
  							    __snake_case,						[
  							        [
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        ],
  							        [
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        ],
  							        [
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        ],
  							        [
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        ],
  							        [
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							            {"score": ANY(__snake_case				), "label": ANY(__snake_case				)},
  							        ],
  							    ],						)
  
  
  
  
  
  
  					@require_torch
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 =							"hf-internal-testing/tiny-random-vit"
  							_snake_case			 =							pipeline("image-classification",						model=__snake_case				)
  
  							_snake_case			 =							image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"				)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],						)
  
  							_snake_case			 =							image_classifier(
  							    [
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							    ],						top_k=2,						)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[
  							        [{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],
  							        [{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],
  							    ],						)
  
  
  
  
  
  
  					@require_tf
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 =							"hf-internal-testing/tiny-random-vit"
  							_snake_case			 =							pipeline("image-classification",						model=__snake_case,						framework="tf"				)
  
  							_snake_case			 =							image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"				)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],						)
  
  							_snake_case			 =							image_classifier(
  							    [
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							    ],						top_k=2,						)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[
  							        [{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],
  							        [{"label": "LABEL_1", "score": 0.5_74}, {"label": "LABEL_0", "score": 0.4_26}],
  							    ],						)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 =							PreTrainedTokenizer()
  
  							# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
  							_snake_case			 =							pipeline(
  							    "image-classification",						model="hf-internal-testing/tiny-random-vit",						tokenizer=__snake_case				)
  
  							self.assertIs(image_classifier.tokenizer,						__snake_case				)
  
  
  
  
  
  
  					@slow
  					@require_torch
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							# Perceiver is not tested by `run_pipeline_test` properly.
  							# That is because the type of feature_extractor and model preprocessor need to be kept
  							# in sync, which is not the case in the current design
  							_snake_case			 =							pipeline("image-classification",						model="deepmind/vision-perceiver-conv"				)
  							_snake_case			 =							image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"				)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[
  							        {"score": 0.43_85, "label": "tabby, tabby cat"},
  							        {"score": 0.3_21, "label": "tiger cat"},
  							        {"score": 0.05_02, "label": "Egyptian cat"},
  							        {"score": 0.01_37, "label": "crib, cot"},
  							        {"score": 0.0_07, "label": "radiator"},
  							    ],						)
  
  							_snake_case			 =							pipeline("image-classification",						model="deepmind/vision-perceiver-fourier"				)
  							_snake_case			 =							image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"				)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[
  							        {"score": 0.56_58, "label": "tabby, tabby cat"},
  							        {"score": 0.13_09, "label": "tiger cat"},
  							        {"score": 0.07_22, "label": "Egyptian cat"},
  							        {"score": 0.07_07, "label": "remote control, remote"},
  							        {"score": 0.00_82, "label": "computer keyboard, keypad"},
  							    ],						)
  
  							_snake_case			 =							pipeline("image-classification",						model="deepmind/vision-perceiver-learned"				)
  							_snake_case			 =							image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"				)
  							self.assertEqual(
  							    nested_simplify(__snake_case,						decimals=4				),						[
  							        {"score": 0.30_22, "label": "tabby, tabby cat"},
  							        {"score": 0.23_62, "label": "Egyptian cat"},
  							        {"score": 0.18_56, "label": "tiger cat"},
  							        {"score": 0.03_24, "label": "remote control, remote"},
  							        {"score": 0.00_96, "label": "quilt, comforter, comfort, puff"},
  							    ],						)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import json
  import os
  import unittest
  
  from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
      VOCAB_FILES_NAMES,
      GPTNeoXJapaneseTokenizer,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  
  @require_tokenizers
  class   lowerCamelCase_							( UpperCAmelCase_, unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				GPTNeoXJapaneseTokenizer
  					lowercase__					=				False
  					lowercase__					=				{"""do_clean_text""": False, """add_prefix_space""": False}
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							super().setUp()
  
  							_snake_case			 = [
  							    "こん",
  							    "こんに",
  							    "にちは",
  							    "ばんは",
  							    "世界,㔺界",
  							    "、",
  							    "。",
  							    "<BR>",
  							    "<SP>",
  							    "<TAB>",
  							    "<URL>",
  							    "<EMAIL>",
  							    "<TEL>",
  							    "<DATE>",
  							    "<PRICE>",
  							    "<BLOCK>",
  							    "<KIGOU>",
  							    "<U2000U2BFF>",
  							    "<|emoji1|>",
  							    "<unk>",
  							    "<|startoftext|>",
  							    "<|endoftext|>",
  							]
  							_snake_case			 = {"emoji": {"\ud83d\ude00": "<|emoji1|>"}, "emoji_inv": {"<|emoji1|>": "\ud83d\ude00"}}  # 😀
  							_snake_case			 = {"unk_token": "<unk>"}
  
  							_snake_case			 = os.path.join(self.tmpdirname,						VOCAB_FILES_NAMES["vocab_file"]				)
  							_snake_case			 = os.path.join(self.tmpdirname,						VOCAB_FILES_NAMES["emoji_file"]				)
  							with open(self.vocab_file,						"w",						encoding="utf-8"				) as vocab_writer:
  									vocab_writer.write("".join([x + "\n" for x in vocab_tokens]				)				)
  							with open(self.emoji_file,						"w"				) as emoji_writer:
  									emoji_writer.write(json.dumps(__UpperCamelCase				)				)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						**__UpperCamelCase				):
  							kwargs.update(self.special_tokens_map				)
  							return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname,						**__UpperCamelCase				)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
  							_snake_case			 = "こんにちは、世界。 \nこんばんは、㔺界。😀"
  							_snake_case			 = "こんにちは、世界。 \nこんばんは、世界。😀"
  							return input_text, output_text
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
  							_snake_case ,					_snake_case			 = self.get_input_output_texts(__UpperCamelCase				)
  							_snake_case			 = tokenizer.encode(__UpperCamelCase,						add_special_tokens=__UpperCamelCase				)
  							_snake_case			 = tokenizer.decode(__UpperCamelCase,						clean_up_tokenization_spaces=__UpperCamelCase				)
  							return text, ids
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							pass  # TODO add if relevant
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							pass  # TODO add if relevant
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							pass  # TODO add if relevant
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = self.get_tokenizer()
  
  							# Testing tokenization
  							_snake_case			 = "こんにちは、世界。　こんばんは、㔺界。"
  							_snake_case			 = ["こん", "にちは", "、", "世界", "。", "<SP>", "こん", "ばんは", "、", "㔺界", "。"]
  							_snake_case			 = tokenizer.tokenize(__UpperCamelCase				)
  							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)
  
  							# Testing conversion to ids without special tokens
  							_snake_case			 = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
  							_snake_case			 = tokenizer.convert_tokens_to_ids(__UpperCamelCase				)
  							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)
  
  							# Testing conversion to ids with special tokens
  							_snake_case			 = tokens + [tokenizer.unk_token]
  							_snake_case			 = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
  							_snake_case			 = tokenizer.convert_tokens_to_ids(__UpperCamelCase				)
  							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)
  
  
  
  
  
  
  					@slow
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = self.tokenizer_class.from_pretrained("abeja/gpt-neox-japanese-2.7b"				)
  
  							_snake_case			 = tokenizer.encode("ありがとう。",						add_special_tokens=__UpperCamelCase				)
  							_snake_case			 = tokenizer.encode("どういたしまして。",						add_special_tokens=__UpperCamelCase				)
  
  							_snake_case			 = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase				)
  							_snake_case			 = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase,						__UpperCamelCase				)
  
  							assert encoded_sentence == ids_a
  							assert encoded_pair == ids_a + ids_a
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							# Intentionally convert some words to accommodate character fluctuations unique to Japanese
  							pass
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							# tokenizer has no padding token
  							pass
  
  
  
  
  
  