





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


UpperCAmelCase__  :     Optional[int]   			= {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

UpperCAmelCase__  :     List[str]   			= {
    """vocab_file""": {
        """unc-nlp/lxmert-base-uncased""": """https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt""",
    },
    """tokenizer_file""": {
        """unc-nlp/lxmert-base-uncased""": (
            """https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json"""
        ),
    },
}

UpperCAmelCase__  :     List[Any]   			= {
    """unc-nlp/lxmert-base-uncased""": 5_12,
}

UpperCAmelCase__  :     str   			= {
    """unc-nlp/lxmert-base-uncased""": {"""do_lower_case""": True},
}

class  __A       (  lowerCamelCase__      ):
				__A								=			VOCAB_FILES_NAMES
				__A								=			PRETRAINED_VOCAB_FILES_MAP
				__A								=			PRETRAINED_INIT_CONFIGURATION
				__A								=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__A								=			LxmertTokenizer


				def __init__(						self				,	UpperCAmelCase_=None				,	UpperCAmelCase_=None				,	UpperCAmelCase_=True				,	UpperCAmelCase_="[UNK]"				,	UpperCAmelCase_="[SEP]"				,	UpperCAmelCase_="[PAD]"				,	UpperCAmelCase_="[CLS]"				,	UpperCAmelCase_="[MASK]"				,	UpperCAmelCase_=True				,	UpperCAmelCase_=None				,	**UpperCAmelCase_				,	):
								super().__init__(
								    UpperCAmelCase_				,	tokenizer_file=UpperCAmelCase_				,	do_lower_case=UpperCAmelCase_				,	unk_token=UpperCAmelCase_				,	sep_token=UpperCAmelCase_				,	pad_token=UpperCAmelCase_				,	cls_token=UpperCAmelCase_				,	mask_token=UpperCAmelCase_				,	tokenize_chinese_chars=UpperCAmelCase_				,	strip_accents=UpperCAmelCase_				,	**UpperCAmelCase_				,	)

								lowerCamelCase			=json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
								if (
								    normalizer_state.get("""lowercase"""				,	UpperCAmelCase_							) != do_lower_case
								    or normalizer_state.get("""strip_accents"""				,	UpperCAmelCase_							) != strip_accents
								    or normalizer_state.get("""handle_chinese_chars"""				,	UpperCAmelCase_							) != tokenize_chinese_chars
								):
												lowerCamelCase			=getattr(UpperCAmelCase_				,	normalizer_state.pop("""type"""							)							)
												lowerCamelCase			=do_lower_case
												lowerCamelCase			=strip_accents
												lowerCamelCase			=tokenize_chinese_chars
												lowerCamelCase			=normalizer_class(**UpperCAmelCase_							)

								lowerCamelCase			=do_lower_case


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_=None							):
								lowerCamelCase			=[self.cls_token_id] + token_ids_a + [self.sep_token_id]

								if token_ids_a:
												output += token_ids_a + [self.sep_token_id]

								return output


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_ = None							):
								lowerCamelCase			=[self.sep_token_id]
								lowerCamelCase			=[self.cls_token_id]
								if token_ids_a is None:
												return len(cls + token_ids_a + sep							) * [0]
								return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_ = None							):
								lowerCamelCase			=self._tokenizer.model.save(UpperCAmelCase_				,	name=UpperCAmelCase_							)
								return tuple(UpperCAmelCase_							)












import inspect
import unittest

class  __A       (  unittest.TestCase      ):


				def _snake_case    (						self							):
								try:
												import diffusers  # noqa: F401
								except ImportError:
												assert False


				def _snake_case    (						self							):
								import diffusers
								from diffusers.dependency_versions_table import deps

								lowerCamelCase			=inspect.getmembers(UpperCAmelCase_				,	inspect.isclass							)

								for cls_name, cls_module in all_classes:
												if "dummy_" in cls_module.__module__:
																for backend in cls_module._backends:
																				if backend == "k_diffusion":
																								lowerCamelCase			="""k-diffusion"""
																				elif backend == "invisible_watermark":
																								lowerCamelCase			="""invisible-watermark"""
																				assert backend in deps, f"""{backend} is not in the deps table!"""





