





import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin



@custom_tokenizers
class    A__  (			__snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :int		       =  BertJapaneseTokenizer
      _UpperCAmelCase      :List[str]		       =  False
      _UpperCAmelCase      :Union[str, Any]		       =  True





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       super().setUp()

       UpperCamelCase      :   Optional[Any]			      =  [
           "[UNK]",
           "[CLS]",
           "[SEP]",
           "こんにちは",
           "こん",
           "にちは",
           "ばんは",
           "##こん",
           "##にちは",
           "##ばんは",
           "世界",
           "##世界",
           "、",
           "##、",
           "。",
           "##。",
       ]

       UpperCamelCase      :   Dict			      =  os.path.join(self.tmpdirname			,				VOCAB_FILES_NAMES["vocab_file"]  )
       with open(self.vocab_file			,				"w"			,				encoding="utf-8"  ) as vocab_writer:
        vocab_writer.write("".join([x + "\n" for x in vocab_tokens]  )  )





      def 			__UpperCamelCase(					self			,				A_  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  "こんにちは、世界。 \nこんばんは、世界。"
       UpperCamelCase      :   List[Any]			      =  "こんにちは 、 世界 。 こんばんは 、 世界 。"
       return input_text, output_text





      def 			__UpperCamelCase(					self			,				A_  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      :   Dict			      =  self.get_input_output_texts(A_  )
       UpperCamelCase      :   Dict			      =  tokenizer.encode(A_			,				add_special_tokens=A_  )
       UpperCamelCase      :   Union[str, Any]			      =  tokenizer.decode(A_			,				clean_up_tokenization_spaces=A_  )
       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'''




       UpperCamelCase      :   Dict			      =  self.tokenizer_class(self.vocab_file  )

       UpperCamelCase      :   Optional[int]			      =  tokenizer.tokenize("こんにちは、世界。\nこんばんは、世界。"  )
       self.assertListEqual(A_			,				["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]  )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_  )			,				[3, 12, 10, 14, 4, 9, 12, 10, 14]  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="mecab"  )
       self.assertIsNotNone(A_  )

       UpperCamelCase      :   List[str]			      =  "こんにちは、世界。\nこんばんは、世界。"
       UpperCamelCase      :   List[Any]			      =  tokenizer.tokenize(A_  )
       self.assertListEqual(A_			,				["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]  )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_  )			,				[3, 12, 10, 14, 4, 9, 12, 10, 14]  )

       UpperCamelCase      :   Union[str, Any]			      =  os.path.join(self.tmpdirname			,				"tokenizer.bin"  )
       with open(A_			,				"wb"  ) as handle:
        pickle.dump(A_			,				A_  )

       with open(A_			,				"rb"  ) as handle:
        UpperCamelCase      :   str			      =  pickle.load(A_  )

       UpperCamelCase      :   List[str]			      =  tokenizer_new.tokenize(A_  )

       self.assertListEqual(A_			,				A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  MecabTokenizer(mecab_dic="ipadic"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップルストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       try:
        UpperCamelCase      :   str			      =  MecabTokenizer(mecab_dic="unidic_lite"  )
       except ModuleNotFoundError:
        return

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       try:
        UpperCamelCase      :   Any			      =  MecabTokenizer(mecab_dic="unidic"  )
       except ModuleNotFoundError:
        return

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  MecabTokenizer(do_lower_case=A_			,				mecab_dic="ipadic"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップルストア", "で", "iphone", "8", "が", "発売", "さ", "れ", "た", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       try:
        UpperCamelCase      :   Any			      =  MecabTokenizer(
            do_lower_case=A_			,				normalize_text=A_			,				mecab_option="-d /usr/local/lib/mecab/dic/jumandic"  )
       except RuntimeError:
        # if dict doesn't exist in the system, previous code raises this error.
        return

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["ｱｯﾌﾟﾙストア", "で", "iPhone", "８", "が", "発売", "さ", "れた", "\u3000", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  MecabTokenizer(normalize_text=A_			,				mecab_dic="ipadic"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["ｱｯﾌﾟﾙストア", "で", "iPhone", "８", "が", "発売", "さ", "れ", "た", "　", "。"]			,				)





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="sudachi"  )
       self.assertIsNotNone(A_  )

       UpperCamelCase      :   Dict			      =  "こんにちは、世界。\nこんばんは、世界。"
       UpperCamelCase      :   Optional[Any]			      =  tokenizer.tokenize(A_  )
       self.assertListEqual(A_			,				["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]  )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_  )			,				[3, 12, 10, 14, 4, 9, 12, 10, 14]  )

       UpperCamelCase      :   List[str]			      =  os.path.join(self.tmpdirname			,				"tokenizer.bin"  )
       with open(A_			,				"wb"  ) as handle:
        pickle.dump(A_			,				A_  )

       with open(A_			,				"rb"  ) as handle:
        UpperCamelCase      :   str			      =  pickle.load(A_  )

       UpperCamelCase      :   List[Any]			      =  tokenizer_new.tokenize(A_  )

       self.assertListEqual(A_			,				A_  )





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  SudachiTokenizer(sudachi_dict_type="core"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				[" ", "\t", "アップル", "ストア", "で", "iPhone", "8", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", " ", "。", " ", " "]			,				)





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="A"  )

       self.assertListEqual(tokenizer.tokenize("外国人参政権"  )			,				["外国", "人", "参政", "権"]  )





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="B"  )

       self.assertListEqual(tokenizer.tokenize("外国人参政権"  )			,				["外国人", "参政権"]  )





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="C"  )

       self.assertListEqual(tokenizer.tokenize("外国人参政権"  )			,				["外国人参政権"]  )





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  SudachiTokenizer(do_lower_case=A_			,				sudachi_dict_type="core"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				[" ", "\t", "アップル", "ストア", "で", "iphone", "8", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", " ", "。", " ", " "]			,				)





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  SudachiTokenizer(normalize_text=A_			,				sudachi_dict_type="core"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				[" ", "\t", "ｱｯﾌﾟﾙ", "ストア", "で", "iPhone", "８", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", "\u3000", "。", " ", " "]			,				)





      @require_sudachi
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  SudachiTokenizer(trim_whitespace=A_			,				sudachi_dict_type="core"  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]			,				)





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="jumanpp"  )
       self.assertIsNotNone(A_  )

       UpperCamelCase      :   Union[str, Any]			      =  "こんにちは、世界。\nこんばんは、世界。"
       UpperCamelCase      :   Tuple			      =  tokenizer.tokenize(A_  )
       self.assertListEqual(A_			,				["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]  )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_  )			,				[3, 12, 10, 14, 4, 9, 12, 10, 14]  )

       UpperCamelCase      :   int			      =  os.path.join(self.tmpdirname			,				"tokenizer.bin"  )
       with open(A_			,				"wb"  ) as handle:
        pickle.dump(A_			,				A_  )

       with open(A_			,				"rb"  ) as handle:
        UpperCamelCase      :   List[str]			      =  pickle.load(A_  )

       UpperCamelCase      :   Optional[int]			      =  tokenizer_new.tokenize(A_  )

       self.assertListEqual(A_			,				A_  )





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  JumanppTokenizer()

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iPhone", "8", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]			,				)





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  JumanppTokenizer(do_lower_case=A_  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iphone", "8", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]			,				)





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  JumanppTokenizer(normalize_text=A_  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["ｱ", "ｯ", "ﾌ", "ﾟ", "ﾙ", "ストア", "で", "iPhone", "８", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]			,				)





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  JumanppTokenizer(trim_whitespace=A_  )

       self.assertListEqual(
           tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "  )			,				["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れた", "。"]			,				)





      @require_jumanpp
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  JumanppTokenizer()

       self.assertListEqual(
           tokenizer.tokenize("ありがとうございますm(_ _)ｍ見つけるのが大変です。"  )			,				["ありがとう", "ございます", "m(_ _)m", "見つける", "の", "が", "大変です", "。"]			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Dict			      =  ["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

       UpperCamelCase      :   List[Any]			      =  {}
       for i, token in enumerate(A_  ):
        UpperCamelCase      :   int			      =  i
       UpperCamelCase      :   Any			      =  WordpieceTokenizer(vocab=A_			,				unk_token="[UNK]"  )

       self.assertListEqual(tokenizer.tokenize(""  )			,				[]  )

       self.assertListEqual(tokenizer.tokenize("こんにちは"  )			,				["こんにちは"]  )

       self.assertListEqual(tokenizer.tokenize("こんばんは"  )			,				["こん", "##ばんは"]  )

       self.assertListEqual(tokenizer.tokenize("こんばんは こんばんにちは こんにちは"  )			,				["こん", "##ばんは", "[UNK]", "こんにちは"]  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp"  )
       UpperCamelCase      :   int			      =  tokenizer.subword_tokenizer

       UpperCamelCase      :   Optional[int]			      =  subword_tokenizer.tokenize("国境 の 長い トンネル を 抜ける と 雪国 であった 。"  )
       self.assertListEqual(A_			,				["▁国境", "▁の", "▁長い", "▁トンネル", "▁を", "▁抜ける", "▁と", "▁雪", "国", "▁であった", "▁。"]  )

       UpperCamelCase      :   List[str]			      =  subword_tokenizer.tokenize("こんばんは こんばん にち は こんにちは"  )
       self.assertListEqual(A_			,				["▁こん", "ばん", "は", "▁こん", "ばん", "▁に", "ち", "▁は", "▁こんにちは"]  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese"  )

       UpperCamelCase      :   Union[str, Any]			      =  tokenizer.encode("ありがとう。"			,				add_special_tokens=A_  )
       UpperCamelCase      :   List[str]			      =  tokenizer.encode("どういたしまして。"			,				add_special_tokens=A_  )

       UpperCamelCase      :   str			      =  tokenizer.build_inputs_with_special_tokens(A_  )
       UpperCamelCase      :   Tuple			      =  tokenizer.build_inputs_with_special_tokens(A_			,				A_  )

       # 2 is for "[CLS]", 3 is for "[SEP]"
       assert encoded_sentence == [2] + text + [3]
       assert encoded_pair == [2] + text + [3] + text_a + [3]



@custom_tokenizers
class    A__  (			__snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :Tuple		       =  BertJapaneseTokenizer
      _UpperCAmelCase      :Union[str, Any]		       =  False





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       super().setUp()

       UpperCamelCase      :   Optional[int]			      =  ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

       UpperCamelCase      :   Any			      =  os.path.join(self.tmpdirname			,				VOCAB_FILES_NAMES["vocab_file"]  )
       with open(self.vocab_file			,				"w"			,				encoding="utf-8"  ) as vocab_writer:
        vocab_writer.write("".join([x + "\n" for x in vocab_tokens]  )  )





      def 			__UpperCamelCase(					self			,				**A_  ):
       '''simple docstring'''




       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname			,				subword_tokenizer_type="character"			,				**A_  )





      def 			__UpperCamelCase(					self			,				A_  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  "こんにちは、世界。 \nこんばんは、世界。"
       UpperCamelCase      :   Union[str, Any]			      =  "こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
       return input_text, output_text





      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'''




       UpperCamelCase      :   List[str]			      =  self.tokenizer_class(self.vocab_file			,				subword_tokenizer_type="character"  )

       UpperCamelCase      :   Optional[int]			      =  tokenizer.tokenize("こんにちは、世界。 \nこんばんは、世界。"  )
       self.assertListEqual(
           A_			,				["こ", "ん", "に", "ち", "は", "、", "世", "界", "。", "こ", "ん", "ば", "ん", "は", "、", "世", "界", "。"]  )
       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(A_  )			,				[3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

       UpperCamelCase      :   int			      =  {}
       for i, token in enumerate(A_  ):
        UpperCamelCase      :   str			      =  i
       UpperCamelCase      :   Dict			      =  CharacterTokenizer(vocab=A_			,				unk_token="[UNK]"  )

       self.assertListEqual(tokenizer.tokenize(""  )			,				[]  )

       self.assertListEqual(tokenizer.tokenize("こんにちは"  )			,				["こ", "ん", "に", "ち", "は"]  )

       self.assertListEqual(tokenizer.tokenize("こんにちほ"  )			,				["こ", "ん", "に", "ち", "[UNK]"]  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char"  )

       UpperCamelCase      :   Optional[int]			      =  tokenizer.encode("ありがとう。"			,				add_special_tokens=A_  )
       UpperCamelCase      :   Tuple			      =  tokenizer.encode("どういたしまして。"			,				add_special_tokens=A_  )

       UpperCamelCase      :   Tuple			      =  tokenizer.build_inputs_with_special_tokens(A_  )
       UpperCamelCase      :   Tuple			      =  tokenizer.build_inputs_with_special_tokens(A_			,				A_  )

       # 2 is for "[CLS]", 3 is for "[SEP]"
       assert encoded_sentence == [2] + text + [3]
       assert encoded_pair == [2] + text + [3] + text_a + [3]



@custom_tokenizers
class    A__  (			unittest.TestCase     ):





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Dict			      =  "cl-tohoku/bert-base-japanese"
       UpperCamelCase      :   List[str]			      =  AutoTokenizer.from_pretrained(A_  )
       self.assertIsInstance(A_			,				A_  )



class    A__  (			unittest.TestCase     ):





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  "cl-tohoku/bert-base-japanese"
       with self.assertLogs("transformers"			,				level="WARNING"  ) as cm:
        BertTokenizer.from_pretrained(A_  )
        self.assertTrue(
            cm.records[0].message.startswith(
                "The tokenizer class you load from this checkpoint is not the same type as the class this function"
                " is called from."  )  )
       UpperCamelCase      :   Dict			      =  "bert-base-cased"
       with self.assertLogs("transformers"			,				level="WARNING"  ) as cm:
        BertJapaneseTokenizer.from_pretrained(A_  )
        self.assertTrue(
            cm.records[0].message.startswith(
                "The tokenizer class you load from this checkpoint is not the same type as the class this function"
                " is called from."  )  )







def 						A_							(	_lowerCAmelCase	)		->					bool:
 UpperCamelCase      :   List[Any]			      =  0
 for ch in input_str:
  UpperCamelCase      :   Optional[Any]			      =  ord(_lowerCAmelCase	)
  UpperCamelCase      :   Optional[Any]			      =  pow(2				,  _lowerCAmelCase	)

  # If we already turned on bit for current character's unicode
  if bitmap >> ch_unicode & 1 == 1:
   return False
  bitmap |= ch_bit_index_on
 return True


if __name__ == "__main__":
    import doctest

    doctest.testmod()
