"""simple docstring"""




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							( SCREAMING_SNAKE_CASE_    ,	unittest.TestCase		):
     _UpperCamelCase							:			List[str]							=		BertJapaneseTokenizer
     _UpperCamelCase							:			Optional[Any]							=		False
     _UpperCamelCase							:			List[Any]							=		True






     def     __A  (		self  ):
       super().setUp()

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

       _lowerCAmelCase						:       Union[str, 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     __A  (		self				,     a__  ):
       _lowerCAmelCase						:       int  			=     """こんにちは、世界。 \nこんばんは、世界。"""
       _lowerCAmelCase						:       Tuple  			=     """こんにちは 、 世界 。 こんばんは 、 世界 。"""
       return input_text, output_text






     def     __A  (		self				,     a__  ):
       _lowerCAmelCase			,	_lowerCAmelCase						:       int  			=     self.get_input_output_texts(a__  )
       _lowerCAmelCase						:       List[Any]  			=     tokenizer.encode(a__				,     add_special_tokens=a__  )
       _lowerCAmelCase						:       Optional[int]  			=     tokenizer.decode(a__				,     clean_up_tokenization_spaces=a__  )
       return text, ids






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     self.tokenizer_class(self.vocab_file  )

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






     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     self.tokenizer_class(self.vocab_file				,     word_tokenizer_type="""mecab"""  )
       self.assertIsNotNone(a__  )

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

       _lowerCAmelCase						:       Dict  			=     os.path.join(self.tmpdirname				,     """tokenizer.bin"""  )
       with open(a__				,     """wb"""  ) as handle:
         pickle.dump(a__				,     a__  )

       with open(a__				,     """rb"""  ) as handle:
         _lowerCAmelCase						:       List[Any]  			=     pickle.load(a__  )

       _lowerCAmelCase						:       List[Any]  			=     tokenizer_new.tokenize(a__  )

       self.assertListEqual(a__				,     a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     MecabTokenizer(mecab_dic="""ipadic"""  )

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






     def     __A  (		self  ):
       try:
         _lowerCAmelCase						:       List[Any]  			=     MecabTokenizer(mecab_dic="""unidic_lite"""  )
       except ModuleNotFoundError:
         return

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






     def     __A  (		self  ):
       try:
         _lowerCAmelCase						:       str  			=     MecabTokenizer(mecab_dic="""unidic"""  )
       except ModuleNotFoundError:
         return

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






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     MecabTokenizer(do_lower_case=a__				,     mecab_dic="""ipadic"""  )

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






     def     __A  (		self  ):
       try:
         _lowerCAmelCase						:       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     __A  (		self  ):
       _lowerCAmelCase						:       List[str]  			=     MecabTokenizer(normalize_text=a__				,     mecab_dic="""ipadic"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[Any]  			=     self.tokenizer_class(self.vocab_file				,     word_tokenizer_type="""sudachi"""  )
       self.assertIsNotNone(a__  )

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

       _lowerCAmelCase						:       Tuple  			=     os.path.join(self.tmpdirname				,     """tokenizer.bin"""  )
       with open(a__				,     """wb"""  ) as handle:
         pickle.dump(a__				,     a__  )

       with open(a__				,     """rb"""  ) as handle:
         _lowerCAmelCase						:       Union[str, Any]  			=     pickle.load(a__  )

       _lowerCAmelCase						:       Tuple  			=     tokenizer_new.tokenize(a__  )

       self.assertListEqual(a__				,     a__  )






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     SudachiTokenizer(sudachi_dict_type="""core"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Tuple  			=     SudachiTokenizer(sudachi_dict_type="""core"""				,     sudachi_split_mode="""A"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     SudachiTokenizer(sudachi_dict_type="""core"""				,     sudachi_split_mode="""B"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     SudachiTokenizer(sudachi_dict_type="""core"""				,     sudachi_split_mode="""C"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     SudachiTokenizer(do_lower_case=a__				,     sudachi_dict_type="""core"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     SudachiTokenizer(normalize_text=a__				,     sudachi_dict_type="""core"""  )

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






     @require_sudachi
     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     SudachiTokenizer(trim_whitespace=a__				,     sudachi_dict_type="""core"""  )

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






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     self.tokenizer_class(self.vocab_file				,     word_tokenizer_type="""jumanpp"""  )
       self.assertIsNotNone(a__  )

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

       _lowerCAmelCase						:       Optional[int]  			=     os.path.join(self.tmpdirname				,     """tokenizer.bin"""  )
       with open(a__				,     """wb"""  ) as handle:
         pickle.dump(a__				,     a__  )

       with open(a__				,     """rb"""  ) as handle:
         _lowerCAmelCase						:       List[Any]  			=     pickle.load(a__  )

       _lowerCAmelCase						:       str  			=     tokenizer_new.tokenize(a__  )

       self.assertListEqual(a__				,     a__  )






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     JumanppTokenizer()

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






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     JumanppTokenizer(do_lower_case=a__  )

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






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     JumanppTokenizer(normalize_text=a__  )

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






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     JumanppTokenizer(trim_whitespace=a__  )

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






     @require_jumanpp
     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     JumanppTokenizer()

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






     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     ["""[UNK]""", """[CLS]""", """[SEP]""", """こんにちは""", """こん""", """にちは""", """ばんは""", """##こん""", """##にちは""", """##ばんは"""]

       _lowerCAmelCase						:       Union[str, Any]  			=     {}
       for i, token in enumerate(a__  ):
         _lowerCAmelCase						:       List[str]  			=     i
       _lowerCAmelCase						:       Optional[int]  			=     WordpieceTokenizer(vocab=a__				,     unk_token="""[UNK]"""  )

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

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

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

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






     def     __A  (		self  ):
       _lowerCAmelCase						:       Any  			=     BertJapaneseTokenizer.from_pretrained("""nlp-waseda/roberta-base-japanese-with-auto-jumanpp"""  )
       _lowerCAmelCase						:       Union[str, Any]  			=     tokenizer.subword_tokenizer

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

       _lowerCAmelCase						:       Optional[int]  			=     subword_tokenizer.tokenize("""こんばんは こんばん にち は こんにちは"""  )
       self.assertListEqual(a__				,     ["""▁こん""", """ばん""", """は""", """▁こん""", """ばん""", """▁に""", """ち""", """▁は""", """▁こんにちは"""]  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     self.tokenizer_class.from_pretrained("""cl-tohoku/bert-base-japanese"""  )

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

       _lowerCAmelCase						:       List[str]  			=     tokenizer.build_inputs_with_special_tokens(a__  )
       _lowerCAmelCase						:       Any  			=     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							( SCREAMING_SNAKE_CASE_    ,	unittest.TestCase		):
     _UpperCamelCase							:			Tuple							=		BertJapaneseTokenizer
     _UpperCamelCase							:			Optional[Any]							=		False






     def     __A  (		self  ):
       super().setUp()

       _lowerCAmelCase						:       Dict  			=     ["""[UNK]""", """[CLS]""", """[SEP]""", """こ""", """ん""", """に""", """ち""", """は""", """ば""", """世""", """界""", """、""", """。"""]

       _lowerCAmelCase						:       List[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     __A  (		self				,     **a__  ):
       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname				,     subword_tokenizer_type="""character"""				,     **a__  )






     def     __A  (		self				,     a__  ):
       _lowerCAmelCase						:       Dict  			=     """こんにちは、世界。 \nこんばんは、世界。"""
       _lowerCAmelCase						:       Optional[Any]  			=     """こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"""
       return input_text, output_text






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       pass  # TODO add if relevant






     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     self.tokenizer_class(self.vocab_file				,     subword_tokenizer_type="""character"""  )

       _lowerCAmelCase						:       Union[str, Any]  			=     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     __A  (		self  ):
       _lowerCAmelCase						:       Optional[Any]  			=     ["""[UNK]""", """[CLS]""", """[SEP]""", """こ""", """ん""", """に""", """ち""", """は""", """ば""", """世""", """界""", """、""", """。"""]

       _lowerCAmelCase						:       List[Any]  			=     {}
       for i, token in enumerate(a__  ):
         _lowerCAmelCase						:       int  			=     i
       _lowerCAmelCase						:       str  			=     CharacterTokenizer(vocab=a__				,     unk_token="""[UNK]"""  )

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

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

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






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[str]  			=     self.tokenizer_class.from_pretrained("""cl-tohoku/bert-base-japanese-char"""  )

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

       _lowerCAmelCase						:       Optional[int]  			=     tokenizer.build_inputs_with_special_tokens(a__  )
       _lowerCAmelCase						:       int  			=     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     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     """cl-tohoku/bert-base-japanese"""
       _lowerCAmelCase						:       Optional[int]  			=     AutoTokenizer.from_pretrained(a__  )
       self.assertIsInstance(a__				,     a__  )







class 						__A							( unittest.TestCase		):






     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     """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."""  )  )
       _lowerCAmelCase						:       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 				UpperCamelCase_(      lowerCamelCase_ )    ->						int:
    if not numbers:
        return 0

    if not isinstance(lowerCamelCase_							, (list, tuple) ) or not all(
        isinstance(lowerCamelCase_							, lowerCamelCase_ ) for number in numbers ):
        raise ValueError('numbers must be an iterable of integers' )

    _lowercase       :							int      		=		numbers[0]

    for i in range(1							, len(lowerCamelCase_ ) ):
        # update the maximum and minimum subarray products
        _lowercase       :							Union[str, Any]      		=		numbers[i]
        if number < 0:
            _lowercase		,				_lowercase       :							Any      		=		min_till_now, max_till_now
        _lowercase       :							Union[str, Any]      		=		max(lowerCamelCase_							, max_till_now * number )
        _lowercase       :							Union[str, Any]      		=		min(lowerCamelCase_							, min_till_now * number )

        # update the maximum product found till now
        _lowercase       :							Optional[Any]      		=		max(lowerCamelCase_							, lowerCamelCase_ )

    return max_prod


