


"""simple docstring"""




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import PaddingStrategy, logging
from .tokenization_realm import RealmTokenizer


lowercase_			     =  logging.get_logger(__name__)

lowercase_			     =  {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

lowercase_			     =  {
    "vocab_file": {
        "google/realm-cc-news-pretrained-embedder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-encoder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-scorer": (
            "https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-openqa": (
            "https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/vocab.txt"
        ),
        "google/realm-orqa-nq-openqa": "https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/vocab.txt",
        "google/realm-orqa-nq-reader": "https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/vocab.txt",
        "google/realm-orqa-wq-openqa": "https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/vocab.txt",
        "google/realm-orqa-wq-reader": "https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/vocab.txt",
    },
    "tokenizer_file": {
        "google/realm-cc-news-pretrained-embedder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/tokenizer.jsont"
        ),
        "google/realm-cc-news-pretrained-encoder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/tokenizer.json"
        ),
        "google/realm-cc-news-pretrained-scorer": (
            "https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/tokenizer.json"
        ),
        "google/realm-cc-news-pretrained-openqa": (
            "https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/tokenizer.json"
        ),
        "google/realm-orqa-nq-openqa": (
            "https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-nq-reader": (
            "https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-wq-openqa": (
            "https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-wq-reader": (
            "https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/tokenizer.json"
        ),
    },
}

lowercase_			     =  {
    "google/realm-cc-news-pretrained-embedder": 5_1_2,
    "google/realm-cc-news-pretrained-encoder": 5_1_2,
    "google/realm-cc-news-pretrained-scorer": 5_1_2,
    "google/realm-cc-news-pretrained-openqa": 5_1_2,
    "google/realm-orqa-nq-openqa": 5_1_2,
    "google/realm-orqa-nq-reader": 5_1_2,
    "google/realm-orqa-wq-openqa": 5_1_2,
    "google/realm-orqa-wq-reader": 5_1_2,
}

lowercase_			     =  {
    "google/realm-cc-news-pretrained-embedder": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-encoder": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-scorer": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-openqa": {"do_lower_case": True},
    "google/realm-orqa-nq-openqa": {"do_lower_case": True},
    "google/realm-orqa-nq-reader": {"do_lower_case": True},
    "google/realm-orqa-wq-openqa": {"do_lower_case": True},
    "google/realm-orqa-wq-reader": {"do_lower_case": True},
}
class 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		__UpperCAmelCase		:			List[str]										=				VOCAB_FILES_NAMES
		__UpperCAmelCase		:			Optional[int]										=				PRETRAINED_VOCAB_FILES_MAP
		__UpperCAmelCase		:			Optional[int]										=				PRETRAINED_INIT_CONFIGURATION
		__UpperCAmelCase		:			int										=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		__UpperCAmelCase		:			Tuple										=				RealmTokenizer

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

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

				__a           =			do_lower_case

		def 			__UpperCAmelCase       (  self							, _a							, **_a      ):
				__a           =			PaddingStrategy.MAX_LENGTH

				__a           =			text
				__a           =			kwargs.pop('''text_pair'''							, _a      )
				__a           =			kwargs.pop('''return_tensors'''							, _a      )

				__a           =			{
				    '''input_ids''': [],
				    '''attention_mask''': [],
				    '''token_type_ids''': [],
				}

				for idx, candidate_text in enumerate(_a      ):
						if batch_text_pair is not None:
								__a           =			batch_text_pair[idx]
						else:
								__a           =			None

						__a           =			super().__call__(_a							, _a							, return_tensors=_a							, **_a      )

						__a           =			encoded_candidates.get('''input_ids'''      )
						__a           =			encoded_candidates.get('''attention_mask'''      )
						__a           =			encoded_candidates.get('''token_type_ids'''      )

						if encoded_input_ids is not None:
								output_data["input_ids"].append(_a      )
						if encoded_attention_mask is not None:
								output_data["attention_mask"].append(_a      )
						if encoded_token_type_ids is not None:
								output_data["token_type_ids"].append(_a      )

				__a           =			{key: item for key, item in output_data.items() if len(_a      ) != 0}

				return BatchEncoding(_a							, tensor_type=_a      )

		def 			__UpperCAmelCase       (  self							, _a							, _a=None      ):
				__a           =			[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 			__UpperCAmelCase       (  self							, _a							, _a = None      ):
				__a           =			[self.sep_token_id]
				__a           =			[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 			__UpperCAmelCase       (  self							, _a							, _a = None      ):
				__a           =			self._tokenizer.model.save(_a							, name=_a      )
				return tuple(_a      )










"""simple docstring"""




import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			inspect.getfile(accelerate.test_utils      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_script.py''']      )
				__a           =			os.path.sep.join(
				    mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_distributed_data_loop.py''']      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_ops.py''']      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.operation_file_path]
				print(f'''Command: {cmd}'''      )
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', inspect.getfile(self.__class__      )]
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )





		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.data_loop_file_path]
				with patch_environment(omp_num_threads=1							, cuda_visible_devices='''0,1'''      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )


if __name__ == "__main__":
				lowercase_			     =  Accelerator()
				lowercase_			     =  (accelerator.state.process_index + 2, 1_0)
				lowercase_			     =  torch.randint(0, 1_0, shape).to(accelerator.device)

				lowercase_			     =  ""

				lowercase_			     =  accelerator.pad_across_processes(tensor)
				if tensora.shape[0] != accelerator.state.num_processes + 1:
								error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
				if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
								error_msg += "Tensors have different values."
				if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
								error_msg += "Padding was not done with the right value (0)."

				lowercase_			     =  accelerator.pad_across_processes(tensor, pad_first=True)
				if tensora.shape[0] != accelerator.state.num_processes + 1:
								error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
				lowercase_			     =  accelerator.state.num_processes - accelerator.state.process_index - 1
				if not torch.equal(tensora[index:], tensor):
								error_msg += "Tensors have different values."
				if not torch.all(tensora[:index] == 0):
								error_msg += "Padding was not done with the right value (0)."

				# Raise error at the end to make sure we don't stop at the first failure.
				if len(error_msg) > 0:
								raise ValueError(error_msg)






