

'''simple docstring'''
import unittest

from transformers import AlbertTokenizer, AlbertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case         =  get_tests_dir('fixtures/spiece.model')


@require_sentencepiece
@require_tokenizers
class        a__  (							lowerCamelCase_  ,				unittest.TestCase  ):
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							AlbertTokenizer
   _SCREAMING_SNAKE_CASE   :					str     	=							AlbertTokenizerFast
   _SCREAMING_SNAKE_CASE   :					int     	=							True
   _SCREAMING_SNAKE_CASE   :					List[Any]     	=							True
   _SCREAMING_SNAKE_CASE   :					int     	=							True


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      super().setUp()

      # We have a SentencePiece fixture for testing
      _lowercase      :				str      					=       AlbertTokenizer(_UpperCamelCase  )
      tokenizer.save_pretrained(self.tmpdirname  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				Union[str, Any]      					=       "this is a test"
      _lowercase      :				Optional[int]      					=       "this is a test"
      return input_text, output_text


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Union[str, Any]      					=       "<pad>"
      _lowercase      :				Tuple      					=       0

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


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[Any]      					=       list(self.get_tokenizer().get_vocab().keys()  )

      self.assertEqual(vocab_keys[0]      ,    "<pad>"  )
      self.assertEqual(vocab_keys[1]      ,    "<unk>"  )
      self.assertEqual(vocab_keys[-1]      ,    "▁eloquent"  )
      self.assertEqual(len(_UpperCamelCase  )      ,    30000  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      self.assertEqual(self.get_tokenizer().vocab_size      ,    30000  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      if not self.test_rust_tokenizer:
         return

      _lowercase      :				Optional[int]      					=       self.get_tokenizer()
      _lowercase      :				Dict      					=       self.get_rust_tokenizer()

      _lowercase      :				List[str]      					=       "I was born in 92000, and this is falsé."

      _lowercase      :				Dict      					=       tokenizer.tokenize(_UpperCamelCase  )
      _lowercase      :				str      					=       rust_tokenizer.tokenize(_UpperCamelCase  )
      self.assertListEqual(_UpperCamelCase      ,    _UpperCamelCase  )

      _lowercase      :				Union[str, Any]      					=       tokenizer.encode(_UpperCamelCase      ,    add_special_tokens=_UpperCamelCase  )
      _lowercase      :				str      					=       rust_tokenizer.encode(_UpperCamelCase      ,    add_special_tokens=_UpperCamelCase  )
      self.assertListEqual(_UpperCamelCase      ,    _UpperCamelCase  )

      _lowercase      :				Optional[int]      					=       self.get_rust_tokenizer()
      _lowercase      :				List[str]      					=       tokenizer.encode(_UpperCamelCase  )
      _lowercase      :				int      					=       rust_tokenizer.encode(_UpperCamelCase  )
      self.assertListEqual(_UpperCamelCase      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				str      					=       AlbertTokenizer(_UpperCamelCase      ,    keep_accents=_UpperCamelCase  )

      _lowercase      :				int      					=       tokenizer.tokenize("This is a test"  )
      self.assertListEqual(_UpperCamelCase      ,    ["▁this", "▁is", "▁a", "▁test"]  )

      self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase  )      ,    [48, 25, 21, 1289]  )

      _lowercase      :				str      					=       tokenizer.tokenize("I was born in 92000, and this is falsé."  )
      self.assertListEqual(
          _UpperCamelCase      ,    ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "é", "."]  )
      _lowercase      :				int      					=       tokenizer.convert_tokens_to_ids(_UpperCamelCase  )
      self.assertListEqual(_UpperCamelCase      ,    [31, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]  )

      _lowercase      :				List[str]      					=       tokenizer.convert_ids_to_tokens(_UpperCamelCase  )
      self.assertListEqual(
          _UpperCamelCase      ,    ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "."]      ,    )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       AlbertTokenizer(_UpperCamelCase  )

      _lowercase      :				Dict      					=       tokenizer.encode("sequence builders"  )
      _lowercase      :				List[Any]      					=       tokenizer.encode("multi-sequence build"  )

      _lowercase      :				List[str]      					=       tokenizer.build_inputs_with_special_tokens(_UpperCamelCase  )
      _lowercase      :				int      					=       tokenizer.build_inputs_with_special_tokens(_UpperCamelCase      ,    _UpperCamelCase  )

      assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
      assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
          tokenizer.sep_token_id
      ]






   @slow
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       {"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, 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, 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, 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, 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], [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, 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]], "input_ids": [[2, 21970, 13, 5, 6092, 167, 28, 7103, 2153, 673, 8, 7028, 12051, 18, 17, 7103, 2153, 673, 8, 3515, 18684, 8, 4461, 6, 1927, 297, 8, 12060, 2607, 18, 13, 5, 4461, 15, 10538, 38, 8, 135, 15, 822, 58, 15, 993, 10363, 15, 1460, 8005, 4461, 15, 993, 255, 2328, 9, 9, 9, 6, 26, 1112, 816, 3260, 13, 5, 103, 2377, 6, 17, 1112, 816, 2782, 13, 5, 103, 10641, 6, 29, 84, 2512, 2430, 782, 18684, 2761, 19, 808, 2430, 2556, 17, 855, 1480, 9477, 4091, 128, 11712, 15, 7103, 2153, 673, 17, 24883, 9990, 9, 3], [2, 11502, 25, 1006, 20, 782, 8, 11809, 855, 1732, 19393, 18667, 37, 367, 21018, 69, 1854, 34, 11860, 19124, 27, 156, 225, 17, 193, 4141, 19, 65, 9124, 9, 3, 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], [2, 14, 2231, 886, 2385, 17659, 84, 14, 16792, 1952, 9, 3, 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]], "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, 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, 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]]}  # noqa: E501
      # fmt: on

      self.tokenizer_integration_test_util(
          expected_encoding=_UpperCamelCase      ,    model_name="albert-base-v2"      ,    revision="6b6560eaf5ff2e250b00c50f380c5389a9c2d82e"      ,    )









'''simple docstring'''
import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available


class        a__  (							lowerCamelCase_  ):
   _SCREAMING_SNAKE_CASE   :					List[Any]     	=							['image_processor', 'tokenizer']
   _SCREAMING_SNAKE_CASE   :					str     	=							'OwlViTImageProcessor'
   _SCREAMING_SNAKE_CASE   :					List[str]     	=							('CLIPTokenizer', 'CLIPTokenizerFast')


   def __init__(			self      ,    _UpperCamelCase=None      ,    _UpperCamelCase=None      ,    **_UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				Dict      					=       None
      if "feature_extractor" in kwargs:
         warnings.warn(
             "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
             " instead."      ,    _UpperCamelCase      ,    )
         _lowercase      :				Optional[int]      					=       kwargs.pop("feature_extractor"  )

      _lowercase      :				str      					=       image_processor if image_processor is not None else feature_extractor
      if image_processor is None:
         raise ValueError("You need to specify an `image_processor`."  )
      if tokenizer is None:
         raise ValueError("You need to specify a `tokenizer`."  )

      super().__init__(_UpperCamelCase      ,    _UpperCamelCase  )


   def __call__(			self      ,    _UpperCamelCase=None      ,    _UpperCamelCase=None      ,    _UpperCamelCase=None      ,    _UpperCamelCase="max_length"      ,    _UpperCamelCase="np"      ,    **_UpperCamelCase  ):





      """simple docstring"""





      if text is None and query_images is None and images is None:
         raise ValueError(
             "You have to specify at least one text or query image or image. All three cannot be none."  )

      if text is not None:
         if isinstance(_UpperCamelCase      ,    _UpperCamelCase  ) or (isinstance(_UpperCamelCase      ,    _UpperCamelCase  ) and not isinstance(text[0]      ,    _UpperCamelCase  )):
            _lowercase      :				int      					=       [self.tokenizer(_UpperCamelCase      ,    padding=_UpperCamelCase      ,    return_tensors=_UpperCamelCase      ,    **_UpperCamelCase  )]

         elif isinstance(_UpperCamelCase      ,    _UpperCamelCase  ) and isinstance(text[0]      ,    _UpperCamelCase  ):
            _lowercase      :				str      					=       []

            # Maximum number of queries across batch
            _lowercase      :				str      					=       max([len(_UpperCamelCase  ) for t in text]  )

            # Pad all batch samples to max number of text queries
            for t in text:
               if len(_UpperCamelCase  ) != max_num_queries:
                  _lowercase      :				List[Any]      					=       t + [" "] * (max_num_queries - len(_UpperCamelCase  ))

               _lowercase      :				Tuple      					=       self.tokenizer(_UpperCamelCase      ,    padding=_UpperCamelCase      ,    return_tensors=_UpperCamelCase      ,    **_UpperCamelCase  )
               encodings.append(_UpperCamelCase  )
         else:
            raise TypeError("Input text should be a string, a list of strings or a nested list of strings"  )

         if return_tensors == "np":
            _lowercase      :				List[Any]      					=       np.concatenate([encoding["input_ids"] for encoding in encodings]      ,    axis=0  )
            _lowercase      :				Optional[Any]      					=       np.concatenate([encoding["attention_mask"] for encoding in encodings]      ,    axis=0  )

         elif return_tensors == "jax" and is_flax_available():
            import jax.numpy as jnp

            _lowercase      :				Union[str, Any]      					=       jnp.concatenate([encoding["input_ids"] for encoding in encodings]      ,    axis=0  )
            _lowercase      :				int      					=       jnp.concatenate([encoding["attention_mask"] for encoding in encodings]      ,    axis=0  )

         elif return_tensors == "pt" and is_torch_available():
            import torch

            _lowercase      :				int      					=       torch.cat([encoding["input_ids"] for encoding in encodings]      ,    dim=0  )
            _lowercase      :				Dict      					=       torch.cat([encoding["attention_mask"] for encoding in encodings]      ,    dim=0  )

         elif return_tensors == "tf" and is_tf_available():
            import tensorflow as tf

            _lowercase      :				Optional[int]      					=       tf.stack([encoding["input_ids"] for encoding in encodings]      ,    axis=0  )
            _lowercase      :				List[str]      					=       tf.stack([encoding["attention_mask"] for encoding in encodings]      ,    axis=0  )

         else:
            raise ValueError("Target return tensor type could not be returned"  )

         _lowercase      :				Optional[int]      					=       BatchEncoding()
         _lowercase      :				List[Any]      					=       input_ids
         _lowercase      :				Dict      					=       attention_mask

      if query_images is not None:
         _lowercase      :				int      					=       BatchEncoding()
         _lowercase      :				Any      					=       self.image_processor(
             _UpperCamelCase      ,    return_tensors=_UpperCamelCase      ,    **_UpperCamelCase  ).pixel_values
         _lowercase      :				Any      					=       query_pixel_values

      if images is not None:
         _lowercase      :				str      					=       self.image_processor(_UpperCamelCase      ,    return_tensors=_UpperCamelCase      ,    **_UpperCamelCase  )

      if text is not None and images is not None:
         _lowercase      :				List[Any]      					=       image_features.pixel_values
         return encoding
      elif query_images is not None and images is not None:
         _lowercase      :				Optional[Any]      					=       image_features.pixel_values
         return encoding
      elif text is not None or query_images is not None:
         return encoding
      else:
         return BatchEncoding(data=dict(**_UpperCamelCase  )      ,    tensor_type=_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.image_processor.post_process(*_UpperCamelCase      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.image_processor.post_process_object_detection(*_UpperCamelCase      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.image_processor.post_process_image_guided_detection(*_UpperCamelCase      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.tokenizer.batch_decode(*_UpperCamelCase      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.tokenizer.decode(*_UpperCamelCase      ,    **_UpperCamelCase  )


   @property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      warnings.warn(
          "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."      ,    _UpperCamelCase      ,    )
      return self.image_processor_class






   @property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      warnings.warn(
          "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."      ,    _UpperCamelCase      ,    )
      return self.image_processor






