

import collections
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase     :   Optional[Any]						     =  logging.get_logger(__name__)

lowerCAmelCase     :   Dict						     =  '▁'

lowerCAmelCase     :   Tuple						     =  {'vocab_file': 'prophetnet.tokenizer'}

lowerCAmelCase     :   Union[str, Any]						     =  {
    'vocab_file': {
        'microsoft/xprophetnet-large-wiki100-cased': (
            'https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/prophetnet.tokenizer'
        ),
    }
}

lowerCAmelCase     :   Optional[Any]						     =  {
    'microsoft/xprophetnet-large-wiki100-cased': {'do_lower_case': False},
}

lowerCAmelCase     :   int						     =  {
    'microsoft/xprophetnet-large-wiki100-cased': 5_12,
}

def    A_      (							a  ):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  List[Any]           =     collections.OrderedDict()
      with open(a					,   'r'					,   encoding='utf-8'  ) as reader:
            SCREAMING_SNAKE_CASE_				:  str           =     reader.readlines()
      for index, token in enumerate(a  ):
            SCREAMING_SNAKE_CASE_				:  Optional[int]           =     token.rstrip('\n'  )
            SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     index
      return vocab



class  _A		(  __magic_name__):
  SCREAMING_SNAKE_CASE    :      Optional[int]       =  VOCAB_FILES_NAMES
  SCREAMING_SNAKE_CASE    :      str       =  PRETRAINED_VOCAB_FILES_MAP
  SCREAMING_SNAKE_CASE    :      List[str]       =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  SCREAMING_SNAKE_CASE    :      Dict       =  ['input_ids', 'attention_mask']

  def __init__(				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE="[SEP]" ,					_SCREAMING_SNAKE_CASE="[SEP]" ,					_SCREAMING_SNAKE_CASE="[SEP]" ,					_SCREAMING_SNAKE_CASE="[UNK]" ,					_SCREAMING_SNAKE_CASE="[PAD]" ,					_SCREAMING_SNAKE_CASE="[CLS]" ,					_SCREAMING_SNAKE_CASE="[MASK]" ,					_SCREAMING_SNAKE_CASE = None ,					**_SCREAMING_SNAKE_CASE ,					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     {} if sp_model_kwargs is None else sp_model_kwargs

        super().__init__(
            bos_token=UpperCAmelCase__ ,					eos_token=UpperCAmelCase__ ,					sep_token=UpperCAmelCase__ ,					unk_token=UpperCAmelCase__ ,					pad_token=UpperCAmelCase__ ,					cls_token=UpperCAmelCase__ ,					mask_token=UpperCAmelCase__ ,					sp_model_kwargs=self.sp_model_kwargs ,					**UpperCAmelCase__ ,					)

        try:
              import sentencepiece as spm
        except ImportError:
              logger.warning(
                  'You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'
                  ' pip install sentencepiece'					)
              raise

        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     spm.SentencePieceProcessor(**self.sp_model_kwargs					)
        self.sp_model.Load(str(UpperCAmelCase__					)					)
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     vocab_file

        # Original fairseq vocab and spm vocab must be "aligned":
        # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
        # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
        # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
        # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

        # put special tokens and [unused] tokens into the vocab
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     {'''[PAD]''': 0, '''[CLS]''': 1, '''[SEP]''': 2, '''[UNK]''': 3, '''[MASK]''': 4}

        for i in range(10					):
              SCREAMING_SNAKE_CASE_				:  Dict           =     f"[unused{i}]"
              SCREAMING_SNAKE_CASE_				:  List[str]           =     5 + i

        # The first "real" token "," has position 15 in the embedding vocab and position 3 in the spm vocab
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     12
        SCREAMING_SNAKE_CASE_				:  str           =     {v: k for k, v in self.fairseq_tokens_to_ids.items()}
        for k in self.fairseq_tokens_to_ids.keys():
              self.unique_no_split_tokens.append(UpperCAmelCase__					)

  def __getstate__(				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  List[Any]           =     self.__dict__.copy()
        SCREAMING_SNAKE_CASE_				:  Dict           =     None
        return state

  def __setstate__(				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Tuple           =     d
        try:
              import sentencepiece as spm
        except ImportError:
              logger.warning(
                  'You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'
                  ' pip install sentencepiece'					)
              raise

        # for backward compatibility
        if not hasattr(self ,					'sp_model_kwargs'					):
              SCREAMING_SNAKE_CASE_				:  Optional[int]           =     {}

        SCREAMING_SNAKE_CASE_				:  Tuple           =     spm.SentencePieceProcessor(**self.sp_model_kwargs					)
        self.sp_model.Load(self.vocab_file					)

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = False					):





        """simple docstring"""







        if already_has_special_tokens:
              return super().get_special_tokens_mask(
                  token_ids_a=UpperCAmelCase__ ,					token_ids_a=UpperCAmelCase__ ,					already_has_special_tokens=UpperCAmelCase__					)

        if token_ids_a is None:
              return ([0] * len(UpperCAmelCase__					)) + [1]
        return ([0] * len(UpperCAmelCase__					)) + [1] + ([0] * len(UpperCAmelCase__					)) + [1]

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = None					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  int           =     [self.sep_token_id]

        if token_ids_a is None:
              return len(token_ids_a + sep					) * [0]
        return len(token_ids_a + sep + sep + token_ids_a + sep					) * [0]

  @property
  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        return len(self.sp_model					) + self.fairseq_offset

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Any           =     {self.convert_ids_to_tokens(UpperCAmelCase__					): i for i in range(self.vocab_size					)}
        vocab.update(self.added_tokens_encoder					)
        return vocab

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        return self.sp_model.encode(UpperCAmelCase__ ,					out_type=UpperCAmelCase__					)

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        if token in self.fairseq_tokens_to_ids:
              return self.fairseq_tokens_to_ids[token]
        SCREAMING_SNAKE_CASE_				:  str           =     self.sp_model.PieceToId(UpperCAmelCase__					)

        # Need to return unknown token if the SP model returned 0
        return spm_id + self.fairseq_offset if spm_id else self.unk_token_id

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        if index in self.fairseq_ids_to_tokens:
              return self.fairseq_ids_to_tokens[index]
        return self.sp_model.IdToPiece(index - self.fairseq_offset					)

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     ''''''.join(UpperCAmelCase__					).replace(UpperCAmelCase__ ,					' '					).strip()
        return out_string

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = None					):





        """simple docstring"""







        if not os.path.isdir(UpperCAmelCase__					):
              logger.error(f"Vocabulary path ({save_directory}) should be a directory"					)
              return
        SCREAMING_SNAKE_CASE_				:  Any           =     os.path.join(
            UpperCAmelCase__ ,					(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']					)

        if os.path.abspath(self.vocab_file					) != os.path.abspath(UpperCAmelCase__					) and os.path.isfile(self.vocab_file					):
              copyfile(self.vocab_file ,					UpperCAmelCase__					)
        elif not os.path.isfile(self.vocab_file					):
              with open(UpperCAmelCase__ ,					'wb'					) as fi:
                    SCREAMING_SNAKE_CASE_				:  Tuple           =     self.sp_model.serialized_model_proto()
                    fi.write(UpperCAmelCase__					)

        return (out_vocab_file,)



  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = None					):





        """simple docstring"""







        if token_ids_a is None:
              return token_ids_a + [self.sep_token_id]
        SCREAMING_SNAKE_CASE_				:  Any           =     [self.sep_token_id]
        return token_ids_a + sep + token_ids_a + sep









import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class  _A		(  __magic_name__   ,     unittest.TestCase):
  SCREAMING_SNAKE_CASE    :      Dict       =  GPTSanJapaneseTokenizer
  SCREAMING_SNAKE_CASE    :      List[Any]       =  False
  SCREAMING_SNAKE_CASE    :      Union[str, Any]       =  {'''do_clean_text''': False, '''add_prefix_space''': False}

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        super().setUp()

        # fmt: off
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     ['こん', 'こんに', 'にちは', 'ばんは', '世界,㔺界', '、', '。', '<BR>', '<SP>', '<TAB>', '<URL>', '<EMAIL>', '<TEL>', '<DATE>', '<PRICE>', '<BLOCK>', '<KIGOU>', '<U2000U2BFF>', '<|emoji1|>', '<unk>', '<|bagoftoken|>', '<|endoftext|>']
        # fmt: on
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
        SCREAMING_SNAKE_CASE_				:  int           =     {'unk_token': '<unk>'}

        SCREAMING_SNAKE_CASE_				:  Any           =     os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['vocab_file']					)
        SCREAMING_SNAKE_CASE_				:  List[str]           =     os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['emoji_file']					)
        with open(self.vocab_file ,					'w' ,					encoding='utf-8'					) as vocab_writer:
              vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]					)					)
        with open(self.emoji_file ,					'w'					) as emoji_writer:
              emoji_writer.write(json.dumps(_SCREAMING_SNAKE_CASE					)					)

  def  UpperCAmelCase    (				self ,					**_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        kwargs.update(self.special_tokens_map					)
        return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname ,					**_SCREAMING_SNAKE_CASE					)

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     'こんにちは、世界。 \nこんばんは、㔺界。😀'
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     'こんにちは、世界。 \nこんばんは、世界。😀'
        return input_text, output_text

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_       ,						SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     self.get_input_output_texts(_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     tokenizer.encode(_SCREAMING_SNAKE_CASE ,					add_special_tokens=_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  Any           =     tokenizer.decode(_SCREAMING_SNAKE_CASE ,					clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE					)
        return text, ids

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        pass  # TODO add if relevant

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        pass  # TODO add if relevant

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        pass  # TODO add if relevant

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  List[str]           =     self.get_tokenizer()

        # Testing tokenization
        SCREAMING_SNAKE_CASE_				:  List[Any]           =     'こんにちは、世界。　こんばんは、㔺界。'
        SCREAMING_SNAKE_CASE_				:  List[str]           =     ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
        SCREAMING_SNAKE_CASE_				:  str           =     tokenizer.tokenize(_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

        # Testing conversion to ids without special tokens
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
        SCREAMING_SNAKE_CASE_				:  List[str]           =     tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

        # Testing conversion to ids with special tokens
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     tokens + [tokenizer.unk_token]
        SCREAMING_SNAKE_CASE_				:  str           =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
        SCREAMING_SNAKE_CASE_				:  str           =     tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     self.get_tokenizer()

        # Testing tokenization
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     'こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'
        SCREAMING_SNAKE_CASE_				:  str           =     'こんにちは、、、、世界。こんばんは、、、、世界。'
        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     tokenizer.encode(_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     tokenizer.decode(_SCREAMING_SNAKE_CASE					)
        self.assertEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

  @slow
  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'					)

        # Testing tokenization
        SCREAMING_SNAKE_CASE_				:  int           =     'こんにちは、世界。'
        SCREAMING_SNAKE_CASE_				:  List[str]           =     'こんばんは、㔺界。😀'
        SCREAMING_SNAKE_CASE_				:  List[str]           =     'こんにちは、世界。こんばんは、世界。😀'
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     tokenizer.encode(prefix_text + input_text					)
        SCREAMING_SNAKE_CASE_				:  int           =     tokenizer.encode('' ,					prefix_text=prefix_text + input_text					)
        SCREAMING_SNAKE_CASE_				:  List[Any]           =     tokenizer.encode(_SCREAMING_SNAKE_CASE ,					prefix_text=_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  List[str]           =     tokenizer.decode(_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  str           =     tokenizer.decode(_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  Dict           =     tokenizer.decode(_SCREAMING_SNAKE_CASE					)
        self.assertEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

  @slow
  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Any           =     self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'					)

        # Testing tokenization
        SCREAMING_SNAKE_CASE_				:  Any           =     'こんにちは、世界。'
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     'こんばんは、㔺界。😀'

        SCREAMING_SNAKE_CASE_				:  int           =     len(tokenizer.encode(_SCREAMING_SNAKE_CASE					)					) - 2
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     len(tokenizer.encode(_SCREAMING_SNAKE_CASE					)					) - 2

        SCREAMING_SNAKE_CASE_				:  str           =     [1] + [0] * (len_prefix + len_text + 1)
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     [1] * (len_prefix + len_text + 1) + [0]
        SCREAMING_SNAKE_CASE_				:  Dict           =     [1] + [1] * (len_prefix) + [0] * (len_text + 1)

        SCREAMING_SNAKE_CASE_				:  Any           =     tokenizer(prefix_text + input_text					).token_type_ids
        SCREAMING_SNAKE_CASE_				:  List[Any]           =     tokenizer('' ,					prefix_text=prefix_text + input_text					).token_type_ids
        SCREAMING_SNAKE_CASE_				:  Tuple           =     tokenizer(_SCREAMING_SNAKE_CASE ,					prefix_text=_SCREAMING_SNAKE_CASE					).token_type_ids
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)

  @slow
  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  int           =     self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'					)

        SCREAMING_SNAKE_CASE_				:  List[Any]           =     tokenizer.encode('あンいワ'					)
        SCREAMING_SNAKE_CASE_				:  Dict           =     tokenizer.encode('' ,					prefix_text='あンいワ'					)
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     tokenizer.encode('いワ' ,					prefix_text='あン'					)

        self.assertEqual(tokenizer.decode(_SCREAMING_SNAKE_CASE					) ,					tokenizer.decode(_SCREAMING_SNAKE_CASE					)					)
        self.assertEqual(tokenizer.decode(_SCREAMING_SNAKE_CASE					) ,					tokenizer.decode(_SCREAMING_SNAKE_CASE					)					)
        self.assertNotEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertNotEqual(_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE					)
        self.assertEqual(x_token_a[1] ,					x_token_a[-1]					)  # SEG token
        self.assertEqual(x_token_a[1] ,					x_token_a[3]					)  # SEG token

  @slow
  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'					)

        SCREAMING_SNAKE_CASE_				:  Tuple           =     [['武田信玄', 'は、'], ['織田信長', 'の配下の、']]
        SCREAMING_SNAKE_CASE_				:  Tuple           =     tokenizer(_SCREAMING_SNAKE_CASE ,					padding=_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     tokenizer.batch_encode_plus(_SCREAMING_SNAKE_CASE ,					padding=_SCREAMING_SNAKE_CASE					)

        # fmt: off
        SCREAMING_SNAKE_CASE_				:  List[str]           =     [[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]]
        SCREAMING_SNAKE_CASE_				:  int           =     [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
        SCREAMING_SNAKE_CASE_				:  Any           =     [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
        # fmt: on
        self.assertListEqual(x_token.input_ids ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(x_token.token_type_ids ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(x_token.attention_mask ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(x_token_a.input_ids ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(x_token_a.token_type_ids ,					_SCREAMING_SNAKE_CASE					)
        self.assertListEqual(x_token_a.attention_mask ,					_SCREAMING_SNAKE_CASE					)

  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        pass



  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        pass






