
'''simple docstring'''



import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
				from tokenizers import Tokenizer
				from tokenizers.models import WordPiece





class      A							(    unittest.TestCase			):



			def A__	(   self    ,       lowerCamelCase__    )     ->						Any:




									'''simple docstring'''



									lowercase__								=    list(tokenizer_class.max_model_input_sizes.keys()    )
									for model_name in sa_models[:1]:
															lowercase__								=    tokenizer_class.from_pretrained(lowerCAmelCase__    )
															self.assertIsNotNone(lowerCAmelCase__    )
															self.assertIsInstance(lowerCAmelCase__    ,       lowerCAmelCase__    )
															self.assertIsInstance(lowerCAmelCase__    ,       lowerCAmelCase__    )

															for special_tok in tokenizer.all_special_tokens:
																					self.assertIsInstance(lowerCAmelCase__    ,       lowerCAmelCase__    )
																					lowercase__								=    tokenizer.convert_tokens_to_ids(lowerCAmelCase__    )
																					self.assertIsInstance(lowerCAmelCase__    ,       lowerCAmelCase__    )



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__ = None    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    pickle.dumps(lowerCAmelCase__    )
									self.assertIsNotNone(lowerCAmelCase__    )

									lowercase__								=    pickle.loads(lowerCAmelCase__    )

									# Ensure is_fast is correctly restored
									self.assertEqual(be_restored.is_fast    ,       be_original.is_fast    )

									# Ensure encodings are potentially correctly restored
									if be_original.is_fast:
															self.assertIsNotNone(be_restored.encodings    )
									else:
															self.assertIsNone(be_restored.encodings    )

									# Ensure the keys are the same
									for original_v, restored_v in zip(be_original.values()    ,       be_restored.values()    ):
															if equal_op:
																					self.assertTrue(equal_op(lowerCAmelCase__    ,       lowerCAmelCase__    )    )
															else:
																					self.assertEqual(lowerCAmelCase__    ,       lowerCAmelCase__    )



			@slow
			def A__	(   self    )     ->						int:




									'''simple docstring'''



									self.check_tokenizer_from_pretrained(lowerCAmelCase__    )



			def A__	(   self    )     ->						Optional[Any]:




									'''simple docstring'''



									self.assertEqual(TensorType("""tf"""    )    ,       TensorType.TENSORFLOW    )
									self.assertEqual(TensorType("""pt"""    )    ,       TensorType.PYTORCH    )
									self.assertEqual(TensorType("""np"""    )    ,       TensorType.NUMPY    )



			@require_tokenizers
			def A__	(   self    )     ->						int:




									'''simple docstring'''



									import numpy as np

									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )
									lowercase__								=    BertTokenizerFast.from_pretrained("""bert-base-cased"""    )

									# Python no tensor
									with self.subTest("""BatchEncoding (Python, return_tensors=None)"""    ):
															self.assert_dump_and_restore(tokenizer_p("""Small example to encode"""    )    )

									with self.subTest("""BatchEncoding (Python, return_tensors=NUMPY)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_p("""Small example to encode"""    ,       return_tensors=TensorType.NUMPY    )    ,       np.array_equal    )

									with self.subTest("""BatchEncoding (Rust, return_tensors=None)"""    ):
															self.assert_dump_and_restore(tokenizer_r("""Small example to encode"""    )    )

									with self.subTest("""BatchEncoding (Rust, return_tensors=NUMPY)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_r("""Small example to encode"""    ,       return_tensors=TensorType.NUMPY    )    ,       np.array_equal    )



			@require_tf
			@require_tokenizers
			def A__	(   self    )     ->						Optional[int]:




									'''simple docstring'''



									import tensorflow as tf

									def tf_array_equals(lowerCamelCase__    ,       lowerCamelCase__    ):
															return tf.reduce_all(tf.equal(lowerCAmelCase__    ,       lowerCAmelCase__    )    )

									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )
									lowercase__								=    BertTokenizerFast.from_pretrained("""bert-base-cased"""    )

									with self.subTest("""BatchEncoding (Python, return_tensors=TENSORFLOW)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_p("""Small example to encode"""    ,       return_tensors=TensorType.TENSORFLOW    )    ,       lowerCAmelCase__    )

									with self.subTest("""BatchEncoding (Rust, return_tensors=TENSORFLOW)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_r("""Small example to encode"""    ,       return_tensors=TensorType.TENSORFLOW    )    ,       lowerCAmelCase__    )



			@require_torch
			@require_tokenizers
			def A__	(   self    )     ->						Any:




									'''simple docstring'''



									import torch

									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )
									lowercase__								=    BertTokenizerFast.from_pretrained("""bert-base-cased"""    )

									with self.subTest("""BatchEncoding (Python, return_tensors=PYTORCH)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_p("""Small example to encode"""    ,       return_tensors=TensorType.PYTORCH    )    ,       torch.equal    )

									with self.subTest("""BatchEncoding (Rust, return_tensors=PYTORCH)"""    ):
															self.assert_dump_and_restore(
															    tokenizer_r("""Small example to encode"""    ,       return_tensors=TensorType.PYTORCH    )    ,       torch.equal    )



			@require_tokenizers
			def A__	(   self    )     ->						str:




									'''simple docstring'''



									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )
									lowercase__								=    BertTokenizerFast.from_pretrained("""bert-base-cased"""    )

									with self.subTest("""Python Tokenizer"""    ):
															self.assertFalse(tokenizer_p("""Small example to_encode"""    ).is_fast    )

									with self.subTest("""Rust Tokenizer"""    ):
															self.assertTrue(tokenizer_r("""Small example to_encode"""    ).is_fast    )



			@require_tokenizers
			def A__	(   self    )     ->						Optional[int]:




									'''simple docstring'''



									lowercase__								=    BertTokenizerFast.from_pretrained("""bert-base-cased"""    )
									lowercase__								=    tokenizer_r(["""Test""", """\xad""", """test"""]    ,       is_split_into_words=lowerCAmelCase__    )

									self.assertEqual(encoded.word_to_tokens(0    )    ,       TokenSpan(start=1    ,       end=2    )    )
									self.assertEqual(encoded.word_to_tokens(1    )    ,       lowerCAmelCase__    )
									self.assertEqual(encoded.word_to_tokens(2    )    ,       TokenSpan(start=2    ,       end=3    )    )



			def A__	(   self    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""np"""    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (2, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (2,)    )
									# test converting the converted
									with CaptureStderr() as cs:
															lowercase__								=    batch.convert_to_tensors(tensor_type="""np"""    )
									self.assertFalse(len(cs.err    )    ,       msg=F'''should have no warning, but got {cs.err}'''    )

									lowercase__								=    BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""np"""    ,       prepend_batch_axis=lowerCAmelCase__    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)    )



			@require_torch
			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									lowercase__								=    BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""pt"""    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (2, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (2,)    )
									# test converting the converted
									with CaptureStderr() as cs:
															lowercase__								=    batch.convert_to_tensors(tensor_type="""pt"""    )
									self.assertFalse(len(cs.err    )    ,       msg=F'''should have no warning, but got {cs.err}'''    )

									lowercase__								=    BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""pt"""    ,       prepend_batch_axis=lowerCAmelCase__    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)    )



			@require_tf
			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									lowercase__								=    BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""tf"""    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (2, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (2,)    )
									# test converting the converted
									with CaptureStderr() as cs:
															lowercase__								=    batch.convert_to_tensors(tensor_type="""tf"""    )
									self.assertFalse(len(cs.err    )    ,       msg=F'''should have no warning, but got {cs.err}'''    )

									lowercase__								=    BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""tf"""    ,       prepend_batch_axis=lowerCAmelCase__    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)    )



			@require_flax
			def A__	(   self    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""jax"""    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (2, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (2,)    )
									# test converting the converted
									with CaptureStderr() as cs:
															lowercase__								=    batch.convert_to_tensors(tensor_type="""jax"""    )
									self.assertFalse(len(cs.err    )    ,       msg=F'''should have no warning, but got {cs.err}'''    )

									lowercase__								=    BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}    )
									lowercase__								=    batch.convert_to_tensors(tensor_type="""jax"""    ,       prepend_batch_axis=lowerCAmelCase__    )
									self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)    )
									self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)    )



			def A__	(   self    )     ->						int:




									'''simple docstring'''



									lowercase__								=    [{"""input_ids""": np.array([0, 1, 2]    )}, {"""input_ids""": np.array([0, 1, 2, 3]    )}]
									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )

									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       np.ndarray    )    )
									self.assertEqual(batch["""input_ids"""].tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )
									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    ,       return_tensors="""np"""    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       np.ndarray    )    )
									self.assertEqual(batch["""input_ids"""].tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )



			@require_torch
			def A__	(   self    )     ->						Union[str, Any]:




									'''simple docstring'''



									import torch

									lowercase__								=    [{"""input_ids""": torch.tensor([0, 1, 2]    )}, {"""input_ids""": torch.tensor([0, 1, 2, 3]    )}]
									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )

									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       torch.Tensor    )    )
									self.assertEqual(batch["""input_ids"""].tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )
									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    ,       return_tensors="""pt"""    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       torch.Tensor    )    )
									self.assertEqual(batch["""input_ids"""].tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )



			@require_tf
			def A__	(   self    )     ->						int:




									'''simple docstring'''



									import tensorflow as tf

									lowercase__								=    [{"""input_ids""": tf.constant([0, 1, 2]    )}, {"""input_ids""": tf.constant([0, 1, 2, 3]    )}]
									lowercase__								=    BertTokenizer.from_pretrained("""bert-base-cased"""    )

									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       tf.Tensor    )    )
									self.assertEqual(batch["""input_ids"""].numpy().tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )
									lowercase__								=    tokenizer.pad(lowerCAmelCase__    ,       padding=lowerCAmelCase__    ,       return_tensors="""tf"""    )
									self.assertTrue(isinstance(batch["""input_ids"""]    ,       tf.Tensor    )    )
									self.assertEqual(batch["""input_ids"""].numpy().tolist()    ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]    )



			@require_tokenizers
			def A__	(   self    )     ->						int:




									'''simple docstring'''



									lowercase__								=    Tokenizer(WordPiece(unk_token="""[UNK]"""    )    )
									PreTrainedTokenizerFast(tokenizer_object=lowerCAmelCase__    )



			@require_tokenizers
			def A__	(   self    )     ->						Union[str, Any]:




									'''simple docstring'''



									lowercase__								=    Tokenizer(WordPiece(unk_token="""[UNK]"""    )    )
									with tempfile.TemporaryDirectory() as tmpdirname:
															bert_tokenizer.save(os.path.join(lowerCAmelCase__    ,       """tokenizer.json"""    )    )
															PreTrainedTokenizerFast(tokenizer_file=os.path.join(lowerCAmelCase__    ,       """tokenizer.json"""    )    )








'''simple docstring'''



import copy
from typing import Dict

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING
from ..bit import BitConfig


__A       =      logging.get_logger(__name__)

__A       =      {
    "google/vit-hybrid-base-bit-384": "https://huggingface.co/vit-hybrid-base-bit-384/resolve/main/config.json",
    # See all ViT hybrid models at https://huggingface.co/models?filter=vit
}





class      A							(    __UpperCAmelCase			):
			lowerCamelCase							:							List[str]    						=					"""vit-hybrid"""



			def __init__(   self    ,       lowerCamelCase__=None    ,       lowerCamelCase__=768    ,       lowerCamelCase__=12    ,       lowerCamelCase__=12    ,       lowerCamelCase__=3_072    ,       lowerCamelCase__="gelu"    ,       lowerCamelCase__=0.0    ,       lowerCamelCase__=0.0    ,       lowerCamelCase__=0.02    ,       lowerCamelCase__=1e-12    ,       lowerCamelCase__=224    ,       lowerCamelCase__=1    ,       lowerCamelCase__=3    ,       lowerCamelCase__=[1, 1_024, 24, 24]    ,       lowerCamelCase__=True    ,       **lowerCamelCase__    ,       )     ->						Optional[Any]:




									'''simple docstring'''



									super().__init__(**lowerCamelCase__    )

									if backbone_config is None:
															logger.info("""`backbone_config` is `None`. Initializing the config with a `BiT` backbone."""    )
															lowercase__								=    {
															    """global_padding""": """same""",
															    """layer_type""": """bottleneck""",
															    """depths""": [3, 4, 9],
															    """out_features""": ["""stage3"""],
															    """embedding_dynamic_padding""": True,
															}

									if isinstance(lowerCamelCase__    ,       lowerCamelCase__    ):
															if "model_type" in backbone_config:
																					lowercase__								=    CONFIG_MAPPING[backbone_config["""model_type"""]]
															else:
																					logger.info(
																					    """`model_type` is not found in `backbone_config`. Use `Bit` as the backbone configuration class."""    )
																					lowercase__								=    BitConfig
															lowercase__								=    backbone_config_class(**lowerCamelCase__    )

									lowercase__								=    backbone_featmap_shape
									lowercase__								=    backbone_config
									lowercase__								=    hidden_size
									lowercase__								=    num_hidden_layers
									lowercase__								=    num_attention_heads
									lowercase__								=    intermediate_size
									lowercase__								=    hidden_act
									lowercase__								=    hidden_dropout_prob
									lowercase__								=    attention_probs_dropout_prob
									lowercase__								=    initializer_range
									lowercase__								=    layer_norm_eps
									lowercase__								=    image_size
									lowercase__								=    patch_size
									lowercase__								=    num_channels
									lowercase__								=    qkv_bias



			def A__	(   self    )     ->						Dict[str, any]:




									'''simple docstring'''



									lowercase__								=    copy.deepcopy(self.__dict__    )
									lowercase__								=    self.backbone_config.to_dict()
									lowercase__								=    self.__class__.model_type
									return output






