
"""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 							snake_case       (     SCREAMING_SNAKE_CASE_							,       unittest.TestCase		):
   a_					:		Optional[int]     					=     GPTNeoXJapaneseTokenizer
   a_					:		Dict     					=     False
   a_					:		Union[str, Any]     					=     {"""do_clean_text""": False, """add_prefix_space""": False}







   def    UpperCAmelCase__	( self)   ->Union[str, Any]:
      super().setUp()

      a_						   =     [
          "こん",
          "こんに",
          "にちは",
          "ばんは",
          "世界,㔺界",
          "、",
          "。",
          "<BR>",
          "<SP>",
          "<TAB>",
          "<URL>",
          "<EMAIL>",
          "<TEL>",
          "<DATE>",
          "<PRICE>",
          "<BLOCK>",
          "<KIGOU>",
          "<U2000U2BFF>",
          "<|emoji1|>",
          "<unk>",
          "<|startoftext|>",
          "<|endoftext|>",
      ]
      a_						   =     {"emoji": {"\ud83d\ude00": "<|emoji1|>"}, "emoji_inv": {"<|emoji1|>": "\ud83d\ude00"}}  # 😀
      a_						   =     {"unk_token": "<unk>"}

      a_						   =     os.path.join(self.tmpdirname       ,							VOCAB_FILES_NAMES["vocab_file"])
      a_						   =     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    UpperCAmelCase__	( self       ,							**__UpperCAmelCase)   ->int:
      kwargs.update(self.special_tokens_map)
      return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname       ,							**__UpperCAmelCase)







   def    UpperCAmelCase__	( self       ,							__UpperCAmelCase)   ->Dict:
      a_						   =     "こんにちは、世界。 \nこんばんは、㔺界。😀"
      a_						   =     "こんにちは、世界。 \nこんばんは、世界。😀"
      return input_text, output_text







   def    UpperCAmelCase__	( self       ,							__UpperCAmelCase)   ->Optional[Any]:
      a_   ,			a_						   =     self.get_input_output_texts(__UpperCAmelCase)
      a_						   =     tokenizer.encode(__UpperCAmelCase       ,							add_special_tokens=__UpperCAmelCase)
      a_						   =     tokenizer.decode(__UpperCAmelCase       ,							clean_up_tokenization_spaces=__UpperCAmelCase)
      return text, ids







   def    UpperCAmelCase__	( self)   ->Any:
      pass  # TODO add if relevant







   def    UpperCAmelCase__	( self)   ->int:
      pass  # TODO add if relevant







   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      pass  # TODO add if relevant







   def    UpperCAmelCase__	( self)   ->List[str]:
      a_						   =     self.get_tokenizer()

      # Testing tokenization
      a_						   =     "こんにちは、世界。　こんばんは、㔺界。"
      a_						   =     ["こん", "にちは", "、", "世界", "。", "<SP>", "こん", "ばんは", "、", "㔺界", "。"]
      a_						   =     tokenizer.tokenize(__UpperCAmelCase)
      self.assertListEqual(__UpperCAmelCase       ,							__UpperCAmelCase)

      # Testing conversion to ids without special tokens
      a_						   =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
      a_						   =     tokenizer.convert_tokens_to_ids(__UpperCAmelCase)
      self.assertListEqual(__UpperCAmelCase       ,							__UpperCAmelCase)

      # Testing conversion to ids with special tokens
      a_						   =     tokens + [tokenizer.unk_token]
      a_						   =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
      a_						   =     tokenizer.convert_tokens_to_ids(__UpperCAmelCase)
      self.assertListEqual(__UpperCAmelCase       ,							__UpperCAmelCase)







   @slow
   def    UpperCAmelCase__	( self)   ->Tuple:
      a_						   =     self.tokenizer_class.from_pretrained("abeja/gpt-neox-japanese-2.7b")

      a_						   =     tokenizer.encode("ありがとう。"       ,							add_special_tokens=__UpperCAmelCase)
      a_						   =     tokenizer.encode("どういたしまして。"       ,							add_special_tokens=__UpperCAmelCase)

      a_						   =     tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase)
      a_						   =     tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase       ,							__UpperCAmelCase)

      assert encoded_sentence == ids_a
      assert encoded_pair == ids_a + ids_a







   def    UpperCAmelCase__	( self)   ->Tuple:
      # Intentionally convert some words to accommodate character fluctuations unique to Japanese
      pass







   def    UpperCAmelCase__	( self)   ->Union[str, Any]:
      # tokenizer has no padding token
      pass

"""simple docstring"""






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import TvltImageProcessor
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase=10 ,   UpperCAmelCase=10 ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Union[str, Any]:

   """simple docstring"""



   a_						   =     []
   for i in range(image_processor_tester.num_frames     ):
      video.append(np.random.randint(255 ,   size=(image_processor_tester.num_channels, width, height) ,   dtype=np.uinta     )     )

   if not numpify and not torchify:
      # PIL expects the channel dimension as last dimension
      a_						   =     [Image.fromarray(np.moveaxis(UpperCAmelCase ,   0 ,   -1     )     ) for frame in video]

   if torchify:
      a_						   =     [torch.from_numpy(UpperCAmelCase     ) for frame in video]

   return video
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase=False ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Optional[Any]:

   """simple docstring"""



   assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

   a_						   =     []
   for i in range(image_processor_tester.batch_size     ):
      if equal_resolution:
         a_						   =     a_						   =     image_processor_tester.max_resolution
      else:
         a_   ,			a_						   =     np.random.choice(
             np.arange(image_processor_tester.min_resolution ,   image_processor_tester.max_resolution     ) ,   2     )
         a_						   =     prepare_video(
             image_processor_tester=UpperCAmelCase ,   width=UpperCAmelCase ,   height=UpperCAmelCase ,   numpify=UpperCAmelCase ,   torchify=UpperCAmelCase ,   )
      video_inputs.append(UpperCAmelCase     )

   return video_inputs





class 							snake_case       (     unittest.TestCase		):







   def __init__( self       ,							__UpperCAmelCase       ,							__UpperCAmelCase=7       ,							__UpperCAmelCase=3       ,							__UpperCAmelCase=4       ,							__UpperCAmelCase=18       ,							__UpperCAmelCase=30       ,							__UpperCAmelCase=4_00       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							)   ->str:
      a_						   =     size if size is not None else {"shortest_edge": 18}
      a_						   =     crop_size if crop_size is not None else {"height": 18, "width": 18}

      a_						   =     parent
      a_						   =     batch_size
      a_						   =     num_channels
      a_						   =     num_frames
      a_						   =     image_size
      a_						   =     min_resolution
      a_						   =     max_resolution
      a_						   =     do_resize
      a_						   =     size
      a_						   =     do_normalize
      a_						   =     image_mean
      a_						   =     image_std
      a_						   =     do_center_crop
      a_						   =     crop_size







   def    UpperCAmelCase__	( self)   ->Tuple:
      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "do_center_crop": self.do_center_crop,
          "crop_size": self.crop_size,
      }






@require_torch
@require_vision
class 							snake_case       (     SCREAMING_SNAKE_CASE_							,       unittest.TestCase		):
   a_					:		int     					=     TvltImageProcessor if is_vision_available() else None







   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      a_						   =     TvltImageProcessorTester(self)







   @property
   def    UpperCAmelCase__	( self)   ->int:
      return self.image_processor_tester.prepare_image_processor_dict()







   def    UpperCAmelCase__	( self)   ->int:
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"image_mean"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"image_std"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_normalize"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_resize"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_center_crop"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"size"))







   def    UpperCAmelCase__	( self)   ->Any:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random PIL videos
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							Image.Image)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)







   def    UpperCAmelCase__	( self)   ->int:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random numpy tensors
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase       ,							numpify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							np.ndarray)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)







   def    UpperCAmelCase__	( self)   ->Tuple:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random PyTorch tensors
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase       ,							torchify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							torch.Tensor)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)