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 					__SCREAMING_SNAKE_CASE       (       UpperCamelCase						,	unittest.TestCase):






       """simple docstring"""

       __UpperCAmelCase       =					BertJapaneseTokenizer
       __UpperCAmelCase       =					False
       __UpperCAmelCase       =					True







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

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

          __snake_case   :			str										=						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      lowercase_   ( self			,		_UpperCAmelCase				):
          __snake_case   :			List[Any]										=						'こんにちは、世界。 \nこんばんは、世界。'
          __snake_case   :			Optional[int]										=						'こんにちは 、 世界 。 こんばんは 、 世界 。'
          return input_text, output_text







       def      lowercase_   ( self			,		_UpperCAmelCase				):
          __snake_case						,       __snake_case   :			Tuple										=						self.get_input_output_texts(_lowerCAmelCase				)
          __snake_case   :			Dict										=						tokenizer.encode(_lowerCAmelCase			,		add_special_tokens=_lowerCAmelCase				)
          __snake_case   :			Union[str, Any]										=						tokenizer.decode(_lowerCAmelCase			,		clean_up_tokenization_spaces=_lowerCAmelCase				)
          return text, ids







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







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







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







       def      lowercase_   ( self				):
          __snake_case   :			Optional[Any]										=						self.tokenizer_class(self.vocab_file				)

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







       def      lowercase_   ( self				):
          __snake_case   :			Dict										=						self.tokenizer_class(self.vocab_file			,		word_tokenizer_type='mecab'				)
          self.assertIsNotNone(_lowerCAmelCase				)

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

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

          with open(_lowerCAmelCase			,		'rb'				) as handle:
             __snake_case   :			str										=						pickle.load(_lowerCAmelCase				)

          __snake_case   :			Tuple										=						tokenizer_new.tokenize(_lowerCAmelCase				)

          self.assertListEqual(_lowerCAmelCase			,		_lowerCAmelCase				)







       def      lowercase_   ( self				):
          __snake_case   :			int										=						MecabTokenizer(mecab_dic='ipadic'				)

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







       def      lowercase_   ( self				):
          try:
             __snake_case   :			Optional[Any]										=						MecabTokenizer(mecab_dic='unidic_lite'				)
          except ModuleNotFoundError:
             return

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







       def      lowercase_   ( self				):
          try:
             __snake_case   :			Any										=						MecabTokenizer(mecab_dic='unidic'				)
          except ModuleNotFoundError:
             return

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







       def      lowercase_   ( self				):
          __snake_case   :			Optional[int]										=						MecabTokenizer(do_lower_case=_lowerCAmelCase			,		mecab_dic='ipadic'				)

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







       def      lowercase_   ( self				):
          try:
             __snake_case   :			Optional[int]										=						MecabTokenizer(
                 do_lower_case=_lowerCAmelCase			,		normalize_text=_lowerCAmelCase			,		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      lowercase_   ( self				):
          __snake_case   :			List[str]										=						MecabTokenizer(normalize_text=_lowerCAmelCase			,		mecab_dic='ipadic'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			Tuple										=						self.tokenizer_class(self.vocab_file			,		word_tokenizer_type='sudachi'				)
          self.assertIsNotNone(_lowerCAmelCase				)

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

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

          with open(_lowerCAmelCase			,		'rb'				) as handle:
             __snake_case   :			int										=						pickle.load(_lowerCAmelCase				)

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

          self.assertListEqual(_lowerCAmelCase			,		_lowerCAmelCase				)







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			Dict										=						SudachiTokenizer(sudachi_dict_type='core'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			List[str]										=						SudachiTokenizer(sudachi_dict_type='core'			,		sudachi_split_mode='A'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			Union[str, Any]										=						SudachiTokenizer(sudachi_dict_type='core'			,		sudachi_split_mode='B'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			Any										=						SudachiTokenizer(sudachi_dict_type='core'			,		sudachi_split_mode='C'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			Dict										=						SudachiTokenizer(do_lower_case=_lowerCAmelCase			,		sudachi_dict_type='core'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			str										=						SudachiTokenizer(normalize_text=_lowerCAmelCase			,		sudachi_dict_type='core'				)

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







       @require_sudachi
       def      lowercase_   ( self				):
          __snake_case   :			str										=						SudachiTokenizer(trim_whitespace=_lowerCAmelCase			,		sudachi_dict_type='core'				)

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







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			List[Any]										=						self.tokenizer_class(self.vocab_file			,		word_tokenizer_type='jumanpp'				)
          self.assertIsNotNone(_lowerCAmelCase				)

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

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

          with open(_lowerCAmelCase			,		'rb'				) as handle:
             __snake_case   :			str										=						pickle.load(_lowerCAmelCase				)

          __snake_case   :			Optional[Any]										=						tokenizer_new.tokenize(_lowerCAmelCase				)

          self.assertListEqual(_lowerCAmelCase			,		_lowerCAmelCase				)







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			Union[str, Any]										=						JumanppTokenizer()

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







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			str										=						JumanppTokenizer(do_lower_case=_lowerCAmelCase				)

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







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			Dict										=						JumanppTokenizer(normalize_text=_lowerCAmelCase				)

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







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			List[str]										=						JumanppTokenizer(trim_whitespace=_lowerCAmelCase				)

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







       @require_jumanpp
       def      lowercase_   ( self				):
          __snake_case   :			Optional[Any]										=						JumanppTokenizer()

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







       def      lowercase_   ( self				):
          __snake_case   :			int										=						['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは']

          __snake_case   :			List[Any]										=						{}
          for i, token in enumerate(_lowerCAmelCase				):
             __snake_case   :			Dict										=						i
          __snake_case   :			int										=						WordpieceTokenizer(vocab=_lowerCAmelCase			,		unk_token='[UNK]'				)

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

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

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

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







       def      lowercase_   ( self				):
          __snake_case   :			Optional[int]										=						BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp'				)
          __snake_case   :			List[str]										=						tokenizer.subword_tokenizer

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

          __snake_case   :			str										=						subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは'				)
          self.assertListEqual(_lowerCAmelCase			,		['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは']				)







       def      lowercase_   ( self				):
          __snake_case   :			List[Any]										=						self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese'				)

          __snake_case   :			List[str]										=						tokenizer.encode('ありがとう。'			,		add_special_tokens=_lowerCAmelCase				)
          __snake_case   :			int										=						tokenizer.encode('どういたしまして。'			,		add_special_tokens=_lowerCAmelCase				)

          __snake_case   :			Union[str, Any]										=						tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase				)
          __snake_case   :			Optional[Any]										=						tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase			,		_lowerCAmelCase				)

          # 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 					__SCREAMING_SNAKE_CASE       (       UpperCamelCase						,	unittest.TestCase):






       """simple docstring"""

       __UpperCAmelCase       =					BertJapaneseTokenizer
       __UpperCAmelCase       =					False







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

          __snake_case   :			int										=						['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

          __snake_case   :			List[str]										=						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      lowercase_   ( self			,		**_UpperCAmelCase				):
          return BertJapaneseTokenizer.from_pretrained(self.tmpdirname			,		subword_tokenizer_type='character'			,		**_lowerCAmelCase				)







       def      lowercase_   ( self			,		_UpperCAmelCase				):
          __snake_case   :			Optional[Any]										=						'こんにちは、世界。 \nこんばんは、世界。'
          __snake_case   :			int										=						'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'
          return input_text, output_text







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







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







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







       def      lowercase_   ( self				):
          __snake_case   :			Union[str, Any]										=						self.tokenizer_class(self.vocab_file			,		subword_tokenizer_type='character'				)

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







       def      lowercase_   ( self				):
          __snake_case   :			Optional[int]										=						['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

          __snake_case   :			Optional[int]										=						{}
          for i, token in enumerate(_lowerCAmelCase				):
             __snake_case   :			Union[str, Any]										=						i
          __snake_case   :			Optional[int]										=						CharacterTokenizer(vocab=_lowerCAmelCase			,		unk_token='[UNK]'				)

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

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

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







       def      lowercase_   ( self				):
          __snake_case   :			Union[str, Any]										=						self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char'				)

          __snake_case   :			Dict										=						tokenizer.encode('ありがとう。'			,		add_special_tokens=_lowerCAmelCase				)
          __snake_case   :			List[Any]										=						tokenizer.encode('どういたしまして。'			,		add_special_tokens=_lowerCAmelCase				)

          __snake_case   :			Dict										=						tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase				)
          __snake_case   :			Union[str, Any]										=						tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase			,		_lowerCAmelCase				)

          # 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 					__SCREAMING_SNAKE_CASE       (       unittest.TestCase):






       """simple docstring"""

       def      lowercase_   ( self				):
          __snake_case   :			int										=						'cl-tohoku/bert-base-japanese'
          __snake_case   :			Optional[Any]										=						AutoTokenizer.from_pretrained(_lowerCAmelCase				)
          self.assertIsInstance(_lowerCAmelCase			,		_lowerCAmelCase				)





class 					__SCREAMING_SNAKE_CASE       (       unittest.TestCase):






       """simple docstring"""

       def      lowercase_   ( self				):
          __snake_case   :			str										=						'cl-tohoku/bert-base-japanese'
          with self.assertLogs('transformers'			,		level='WARNING'				) as cm:
             BertTokenizer.from_pretrained(_lowerCAmelCase				)
             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.'				)				)
          __snake_case   :			Optional[int]										=						'bert-base-cased'
          with self.assertLogs('transformers'			,		level='WARNING'				) as cm:
             BertJapaneseTokenizer.from_pretrained(_lowerCAmelCase				)
             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.'				)				)










'''simple docstring'''


from __future__ import annotations


def 						__a(SCREAMING_SNAKE_CASE_	:       int | float | str		,							SCREAMING_SNAKE_CASE_	:       int | float | str     ):



    '''simple docstring'''





    if nth_term == "":
        return [""]
    _lowerCAmelCase						      =   int(SCREAMING_SNAKE_CASE_     )
    _lowerCAmelCase						      =   int(SCREAMING_SNAKE_CASE_     )
    _lowerCAmelCase						      =   []
    for temp in range(int(SCREAMING_SNAKE_CASE_     )     ):
        series.append(F'''1 / {pow(temp + 1		,							int(SCREAMING_SNAKE_CASE_     )     )}''' if series else "1"     )
    return series


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       _SCREAMING_SNAKE_CASE									=				int(input("Enter the last number (nth term) of the P-Series"))
       _SCREAMING_SNAKE_CASE									=				int(input("Enter the power for  P-Series"))
       print("Formula of P-Series => 1+1/2^p+1/3^p ..... 1/n^p")
       print(p_series(nth_term, power))


