code: 
  
  
  '''simple docstring'''
  
  
  
  
  import json
  import os
  from functools import lru_cache
  from typing import TYPE_CHECKING, List, Optional, Tuple, Union
  
  import numpy as np
  import regex as re
  
  from ...utils import is_tf_available, is_torch_available, logging
  
  
  if TYPE_CHECKING:
  				if is_torch_available():
  								import torch
  				if is_tf_available():
  								import tensorflow as tf
  
  from ...tokenization_utils import AddedToken, PreTrainedTokenizer
  
  
  __lowercase  :      Any      		=				logging.get_logger(__name__)
  
  __lowercase  :      Any      		=				{
      """vocab_file""": """vocab.json""",
      """merges_file""": """merges.txt""",
  }
  
  __lowercase  :      Union[str, Any]      		=				{
      """vocab_file""": {
          """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json""",
      },
      """merges_file""": {
          """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt""",
      },
  }
  
  __lowercase  :      Tuple      		=				{
      """Salesforce/codegen-350M-mono""": 20_48,
  }
  
  @lru_cache()
  def 							a_       (						)			->Optional[Any]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase		:      Any											=					(
  				    list(range(ord("!"    )							,						ord("~"    ) + 1    )    ) + list(range(ord("¡"    )							,						ord("¬"    ) + 1    )    ) + list(range(ord("®"    )							,						ord("ÿ"    ) + 1    )    )
  				)
  				__lowerCamelCase		:      Optional[Any]											=					bs[:]
  				__lowerCamelCase		:      int											=					0
  				for b in range(2**8    ):
  								if b not in bs:
  												bs.append(lowercase__    )
  												cs.append(2**8 + n    )
  												n += 1
  				__lowerCamelCase		:      Tuple											=					[chr(lowercase__    ) for n in cs]
  				return dict(zip(lowercase__							,						lowercase__    )    )
  
  def 							a_       (						lowercase    )			->Dict:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase		:      int											=					set()
  				__lowerCamelCase		:      int											=					word[0]
  				for char in word[1:]:
  								pairs.add((prev_char, char)    )
  								__lowerCamelCase		:      Any											=					char
  				return pairs
  
  
  
  
  
  class _snake_case   ( A_   ):
  							"""simple docstring"""
  
  
  
  
  
  							__a												=     VOCAB_FILES_NAMES
  							__a												=     PRETRAINED_VOCAB_FILES_MAP
  							__a												=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  							__a												=     ['''input_ids''', '''attention_mask''']
  
  
  
  
  
  
  
  							def __init__(   self			,				__A			,				__A			,				__A="replace"			,				__A="<|endoftext|>"			,				__A="<|endoftext|>"			,				__A="<|endoftext|>"			,				__A=None			,				__A=False			,				__A=False			,				**__A			,				)     ->Optional[int]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      List[str]											=					AddedToken(__A			,				lstrip=__A			,				rstrip=__A	) if isinstance(__A			,				__A	) else bos_token
  											__lowerCamelCase		:      Any											=					AddedToken(__A			,				lstrip=__A			,				rstrip=__A	) if isinstance(__A			,				__A	) else eos_token
  											__lowerCamelCase		:      Tuple											=					AddedToken(__A			,				lstrip=__A			,				rstrip=__A	) if isinstance(__A			,				__A	) else unk_token
  											__lowerCamelCase		:      List[str]											=					AddedToken(__A			,				lstrip=__A			,				rstrip=__A	) if isinstance(__A			,				__A	) else pad_token
  											super().__init__(
  											    errors=__A			,				unk_token=__A			,				bos_token=__A			,				eos_token=__A			,				pad_token=__A			,				add_prefix_space=__A			,				add_bos_token=__A			,				**__A			,				)
  											__lowerCamelCase		:      List[str]											=					add_bos_token
  
  											with open(__A			,				encoding="utf-8"	) as vocab_handle:
  															__lowerCamelCase		:      List[str]											=					json.load(__A	)
  											__lowerCamelCase		:      List[str]											=					{v: k for k, v in self.encoder.items()}
  											__lowerCamelCase		:      List[Any]											=					errors  # how to handle errors in decoding
  											__lowerCamelCase		:      List[str]											=					bytes_to_unicode()
  											__lowerCamelCase		:      List[str]											=					{v: k for k, v in self.byte_encoder.items()}
  											with open(__A			,				encoding="utf-8"	) as merges_handle:
  															__lowerCamelCase		:      Optional[int]											=					merges_handle.read().split("\n"	)[1:-1]
  											__lowerCamelCase		:      str											=					[tuple(merge.split()	) for merge in bpe_merges]
  											__lowerCamelCase		:      List[str]											=					dict(zip(__A			,				range(len(__A	)	)	)	)
  											__lowerCamelCase		:      Optional[int]											=					{}
  											__lowerCamelCase		:      int											=					add_prefix_space
  
  											# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
  											__lowerCamelCase		:      int											=					re.compile(r"\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"	)
  
  
  
  
  
  
  
  							@property
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->List[Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return len(self.encoder	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->Tuple:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return dict(self.encoder			,				**self.added_tokens_encoder	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->str:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											if token in self.cache:
  															return self.cache[token]
  											__lowerCamelCase		:      Any											=					tuple(__A	)
  											__lowerCamelCase		:      str											=					get_pairs(__A	)
  
  											if not pairs:
  															return token
  
  											while True:
  															__lowerCamelCase		:      List[Any]											=					min(__A			,				key=lambda __A	: self.bpe_ranks.get(__A			,				float("inf"	)	)	)
  															if bigram not in self.bpe_ranks:
  																			break
  															__lowerCamelCase						,					__lowerCamelCase		:      List[Any]											=					bigram
  															__lowerCamelCase		:      List[str]											=					[]
  															__lowerCamelCase		:      Union[str, Any]											=					0
  															while i < len(__A	):
  																			try:
  																							__lowerCamelCase		:      Optional[int]											=					word.index(__A			,				__A	)
  																			except ValueError:
  																							new_word.extend(word[i:]	)
  																							break
  																			else:
  																							new_word.extend(word[i:j]	)
  																							__lowerCamelCase		:      Any											=					j
  
  																			if word[i] == first and i < len(__A	) - 1 and word[i + 1] == second:
  																							new_word.append(first + second	)
  																							i += 2
  																			else:
  																							new_word.append(word[i]	)
  																							i += 1
  															__lowerCamelCase		:      Optional[int]											=					tuple(__A	)
  															__lowerCamelCase		:      Union[str, Any]											=					new_word
  															if len(__A	) == 1:
  																			break
  															else:
  																			__lowerCamelCase		:      str											=					get_pairs(__A	)
  											__lowerCamelCase		:      Optional[Any]											=					" ".join(__A	)
  											__lowerCamelCase		:      Tuple											=					word
  											return word
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A=None	)     ->Dict:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											if self.add_bos_token:
  															__lowerCamelCase		:      int											=					[self.bos_token_id]
  											else:
  															__lowerCamelCase		:      str											=					[]
  
  											__lowerCamelCase		:      List[Any]											=					bos_token_ids + token_ids_a
  
  											if token_ids_a is None:
  															return output
  
  											return output + bos_token_ids + token_ids_a
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      List[str]											=					[]
  											for token in re.findall(self.pat			,				__A	):
  															__lowerCamelCase		:      Dict											=					"".join(
  															    self.byte_encoder[b] for b in token.encode("utf-8"	)	)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
  															bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__A	).split(" "	)	)
  											return bpe_tokens
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->Optional[Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return self.encoder.get(__A			,				self.encoder.get(self.unk_token	)	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->Any:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return self.decoder.get(__A	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->Union[str, Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      str											=					"".join(__A	)
  											__lowerCamelCase		:      str											=					bytearray([self.byte_decoder[c] for c in text]	).decode("utf-8"			,				errors=self.errors	)
  											return text
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A = None	)     ->Dict:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											if not os.path.isdir(__A	):
  															logger.error(f'Vocabulary path ({save_directory}) should be a directory'	)
  															return
  											__lowerCamelCase		:      Optional[Any]											=					os.path.join(
  											    __A			,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]	)
  											__lowerCamelCase		:      List[Any]											=					os.path.join(
  											    __A			,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]	)
  
  											with open(__A			,				"w"			,				encoding="utf-8"	) as f:
  															f.write(json.dumps(self.encoder			,				indent=2			,				sort_keys=__A			,				ensure_ascii=__A	) + "\n"	)
  
  											__lowerCamelCase		:      Union[str, Any]											=					0
  											with open(__A			,				"w"			,				encoding="utf-8"	) as writer:
  															writer.write("#version: 0.2\n"	)
  															for bpe_tokens, token_index in sorted(self.bpe_ranks.items()			,				key=lambda __A	: kv[1]	):
  																			if index != token_index:
  																							logger.warning(
  																							    f'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
  																							    " Please check that the tokenizer is not corrupted!"	)
  																							__lowerCamelCase		:      str											=					token_index
  																			writer.write(" ".join(__A	) + "\n"	)
  																			index += 1
  
  											return vocab_file, merge_file
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A=False			,				**__A	)     ->Optional[int]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      str											=					kwargs.pop("add_prefix_space"			,				self.add_prefix_space	)
  											if is_split_into_words or add_prefix_space:
  															__lowerCamelCase		:      Union[str, Any]											=					" " + text
  											return (text, kwargs)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A = False			,				__A = None			,				__A = None			,				**__A			,				)     ->Any:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Dict											=					super()._decode(
  											    token_ids=__A			,				skip_special_tokens=__A			,				clean_up_tokenization_spaces=__A			,				**__A			,				)
  
  											if truncate_before_pattern is not None and len(__A	) > 0:
  															__lowerCamelCase		:      Optional[Any]											=					self.truncate(__A			,				__A	)
  
  											return decoded_text
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A	)     ->Optional[int]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											def find_re(__A			,				__A			,				__A	):
  															__lowerCamelCase		:      Union[str, Any]											=					pattern.search(__A			,				__A	)
  															return m.start() if m else -1
  
  											__lowerCamelCase		:      List[str]											=					[re.compile(__A			,				re.MULTILINE	) for pattern in truncate_before_pattern]
  
  											__lowerCamelCase		:      str											=					list(re.finditer("^print"			,				__A			,				re.MULTILINE	)	)
  
  											if len(__A	) > 1:
  															__lowerCamelCase		:      Union[str, Any]											=					completion[: prints[1].start()]
  
  											__lowerCamelCase		:      List[Any]											=					list(re.finditer("^def"			,				__A			,				re.MULTILINE	)	)
  
  											if len(__A	) > 1:
  															__lowerCamelCase		:      Any											=					completion[: defs[1].start()]
  
  											__lowerCamelCase		:      List[str]											=					0
  
  											__lowerCamelCase		:      Optional[Any]											=					[
  											    pos for pos in [find_re(__A			,				__A			,				__A	) for terminal in terminals] if pos != -1
  											]
  
  											if len(__A	) > 0:
  															return completion[: min(__A	)]
  											else:
  															return completion
  
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  
  
  
  import json
  from typing import List, Optional, Tuple
  
  from tokenizers import pre_tokenizers, processors
  
  from ...tokenization_utils_base import AddedToken, BatchEncoding
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_longformer import LongformerTokenizer
  
  
  __lowercase  :      str      		=				logging.get_logger(__name__)
  
  __lowercase  :      Any      		=				{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}
  
  __lowercase  :      Optional[Any]      		=				{
      """vocab_file""": {
          """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json""",
          """allenai/longformer-large-4096""": (
              """https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json"""
          ),
          """allenai/longformer-large-4096-finetuned-triviaqa""": (
              """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json"""
          ),
          """allenai/longformer-base-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json"""
          ),
          """allenai/longformer-large-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json"""
          ),
      },
      """merges_file""": {
          """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt""",
          """allenai/longformer-large-4096""": (
              """https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt"""
          ),
          """allenai/longformer-large-4096-finetuned-triviaqa""": (
              """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt"""
          ),
          """allenai/longformer-base-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt"""
          ),
          """allenai/longformer-large-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt"""
          ),
      },
      """tokenizer_file""": {
          """allenai/longformer-base-4096""": (
              """https://huggingface.co/allenai/longformer-base-4096/resolve/main/tokenizer.json"""
          ),
          """allenai/longformer-large-4096""": (
              """https://huggingface.co/allenai/longformer-large-4096/resolve/main/tokenizer.json"""
          ),
          """allenai/longformer-large-4096-finetuned-triviaqa""": (
              """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/tokenizer.json"""
          ),
          """allenai/longformer-base-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/tokenizer.json"""
          ),
          """allenai/longformer-large-4096-extra.pos.embd.only""": (
              """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/tokenizer.json"""
          ),
      },
  }
  
  __lowercase  :      Tuple      		=				{
      """allenai/longformer-base-4096""": 40_96,
      """allenai/longformer-large-4096""": 40_96,
      """allenai/longformer-large-4096-finetuned-triviaqa""": 40_96,
      """allenai/longformer-base-4096-extra.pos.embd.only""": 40_96,
      """allenai/longformer-large-4096-extra.pos.embd.only""": 40_96,
  }
  
  
  
  
  
  class _snake_case   ( a__   ):
  							"""simple docstring"""
  
  
  
  
  
  							__a												=     VOCAB_FILES_NAMES
  							__a												=     PRETRAINED_VOCAB_FILES_MAP
  							__a												=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  							__a												=     ['''input_ids''', '''attention_mask''']
  							__a												=     LongformerTokenizer
  
  
  
  
  
  
  
  							def __init__(   self			,				__A=None			,				__A=None			,				__A=None			,				__A="replace"			,				__A="<s>"			,				__A="</s>"			,				__A="</s>"			,				__A="<s>"			,				__A="<unk>"			,				__A="<pad>"			,				__A="<mask>"			,				__A=False			,				__A=True			,				**__A			,				)     ->Dict:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											super().__init__(
  											    __A			,				__A			,				tokenizer_file=__A			,				errors=__A			,				bos_token=__A			,				eos_token=__A			,				sep_token=__A			,				cls_token=__A			,				unk_token=__A			,				pad_token=__A			,				mask_token=__A			,				add_prefix_space=__A			,				trim_offsets=__A			,				**__A			,				)
  
  											__lowerCamelCase		:      int											=					json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()	)
  											if pre_tok_state.get("add_prefix_space"			,				__A	) != add_prefix_space:
  															__lowerCamelCase		:      Any											=					getattr(__A			,				pre_tok_state.pop("type"	)	)
  															__lowerCamelCase		:      Any											=					add_prefix_space
  															__lowerCamelCase		:      Union[str, Any]											=					pre_tok_class(**__A	)
  
  											__lowerCamelCase		:      Any											=					add_prefix_space
  
  											__lowerCamelCase		:      int											=					"post_processor"
  											__lowerCamelCase		:      Optional[int]											=					getattr(self.backend_tokenizer			,				__A			,				__A	)
  											if tokenizer_component_instance:
  															__lowerCamelCase		:      Tuple											=					json.loads(tokenizer_component_instance.__getstate__()	)
  
  															# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
  															if "sep" in state:
  																			__lowerCamelCase		:      Dict											=					tuple(state["sep"]	)
  															if "cls" in state:
  																			__lowerCamelCase		:      Union[str, Any]											=					tuple(state["cls"]	)
  
  															__lowerCamelCase		:      Union[str, Any]											=					False
  
  															if state.get("add_prefix_space"			,				__A	) != add_prefix_space:
  																			__lowerCamelCase		:      Dict											=					add_prefix_space
  																			__lowerCamelCase		:      str											=					True
  
  															if state.get("trim_offsets"			,				__A	) != trim_offsets:
  																			__lowerCamelCase		:      Tuple											=					trim_offsets
  																			__lowerCamelCase		:      Optional[int]											=					True
  
  															if changes_to_apply:
  																			__lowerCamelCase		:      List[Any]											=					getattr(__A			,				state.pop("type"	)	)
  																			__lowerCamelCase		:      int											=					component_class(**__A	)
  																			setattr(self.backend_tokenizer			,				__A			,				__A	)
  
  
  
  
  
  
  
  							@property
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->str:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											if self._mask_token is None:
  															if self.verbose:
  																			logger.error("Using mask_token, but it is not set yet."	)
  															return None
  											return str(self._mask_token	)
  
  
  
  
  
  
  
  							@mask_token.setter
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      List[Any]											=					AddedToken(__A			,				lstrip=__A			,				rstrip=__A	) if isinstance(__A			,				__A	) else value
  											__lowerCamelCase		:      Optional[int]											=					value
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				*__A			,				**__A	)     ->BatchEncoding:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Optional[int]											=					kwargs.get("is_split_into_words"			,				__A	)
  											assert self.add_prefix_space or not is_split_into_words, (
  											    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
  											    "to use it with pretokenized inputs."
  											)
  
  											return super()._batch_encode_plus(*__A			,				**__A	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				*__A			,				**__A	)     ->BatchEncoding:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      str											=					kwargs.get("is_split_into_words"			,				__A	)
  
  											assert self.add_prefix_space or not is_split_into_words, (
  											    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
  											    "to use it with pretokenized inputs."
  											)
  
  											return super()._encode_plus(*__A			,				**__A	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A = None	)     ->Tuple[str]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      List[str]											=					self._tokenizer.model.save(__A			,				name=__A	)
  											return tuple(__A	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A=None	)     ->Union[str, Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Any											=					[self.bos_token_id] + token_ids_a + [self.eos_token_id]
  											if token_ids_a is None:
  															return output
  
  											return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A			,				__A = None	)     ->List[int]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      List[str]											=					[self.sep_token_id]
  											__lowerCamelCase		:      Tuple											=					[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 + sep + token_ids_a + sep	) * [0]
  
  
  
  
  
  