

"""simple docstring"""





import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCamelCase    : Dict				 =						get_tests_dir('''fixtures/test_sentencepiece.model''')


if is_torch_available():
							from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__UpperCamelCase    : int				 =						2_5_6_0_4_7
__UpperCamelCase    : List[Any]				 =						2_5_6_1_4_5







@require_sentencepiece
@require_tokenizers
class 							SCREAMING_SNAKE_CASE   (						a_       ,				unittest.TestCase			):






					"""simple docstring"""



					lowercase__												=			NllbTokenizer
					lowercase__												=			NllbTokenizerFast
					lowercase__												=			True
					lowercase__												=			True
					lowercase__												=			{}







					def 			__lowerCAmelCase					(			self     :							Dict						):
						super().setUp()

						# We have a SentencePiece fixture for testing
						lowerCAmelCase__      :		Optional[int]    							=      NllbTokenizer(lowercase_  ,keep_accents=lowercase_						)
						tokenizer.save_pretrained(self.tmpdirname						)







					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Dict    							=      NllbTokenizer(lowercase_  ,keep_accents=lowercase_						)

						lowerCAmelCase__      :		List[str]    							=      tokenizer.tokenize('''This is a test'''						)
						self.assertListEqual(lowercase_  ,['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']						)

						self.assertListEqual(
						    tokenizer.convert_tokens_to_ids(lowercase_						)  ,[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]  ,)

						lowerCAmelCase__      :		List[str]    							=      tokenizer.tokenize('''I was born in 92000, and this is falsé.'''						)
						self.assertListEqual(
						    lowercase_  ,[
						        SPIECE_UNDERLINE + '''I''',
						        SPIECE_UNDERLINE + '''was''',
						        SPIECE_UNDERLINE + '''b''',
						        '''or''',
						        '''n''',
						        SPIECE_UNDERLINE + '''in''',
						        SPIECE_UNDERLINE + '''''',
						        '''9''',
						        '''2''',
						        '''0''',
						        '''0''',
						        '''0''',
						        ''',''',
						        SPIECE_UNDERLINE + '''and''',
						        SPIECE_UNDERLINE + '''this''',
						        SPIECE_UNDERLINE + '''is''',
						        SPIECE_UNDERLINE + '''f''',
						        '''al''',
						        '''s''',
						        '''é''',
						        '''.''',
						    ]  ,)
						lowerCAmelCase__      :		str    							=      tokenizer.convert_tokens_to_ids(lowercase_						)
						self.assertListEqual(
						    lowercase_  ,[
						        value + tokenizer.fairseq_offset
						        for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
						    ]  ,)

						lowerCAmelCase__      :		str    							=      tokenizer.convert_ids_to_tokens(lowercase_						)
						self.assertListEqual(
						    lowercase_  ,[
						        SPIECE_UNDERLINE + '''I''',
						        SPIECE_UNDERLINE + '''was''',
						        SPIECE_UNDERLINE + '''b''',
						        '''or''',
						        '''n''',
						        SPIECE_UNDERLINE + '''in''',
						        SPIECE_UNDERLINE + '''''',
						        '''<unk>''',
						        '''2''',
						        '''0''',
						        '''0''',
						        '''0''',
						        ''',''',
						        SPIECE_UNDERLINE + '''and''',
						        SPIECE_UNDERLINE + '''this''',
						        SPIECE_UNDERLINE + '''is''',
						        SPIECE_UNDERLINE + '''f''',
						        '''al''',
						        '''s''',
						        '''<unk>''',
						        '''.''',
						    ]  ,)







					def 			__lowerCAmelCase					(			self     :							int						):
						lowerCAmelCase__      :		List[str]    							=      (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-nllb''', {})
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'						):
								lowerCAmelCase__      :		Tuple    							=      self.rust_tokenizer_class.from_pretrained(lowercase_  ,**lowercase_						)
								lowerCAmelCase__      :		Tuple    							=      self.tokenizer_class.from_pretrained(lowercase_  ,**lowercase_						)

								lowerCAmelCase__      :		List[str]    							=      tempfile.mkdtemp()

								lowerCAmelCase__      :		List[Any]    							=      tokenizer_r.save_pretrained(lowercase_						)
								lowerCAmelCase__      :		Tuple    							=      tokenizer_p.save_pretrained(lowercase_						)

								# Checks it save with the same files + the tokenizer.json file for the fast one
								self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files						)						)
								lowerCAmelCase__      :		Union[str, Any]    							=      tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f						)
								self.assertSequenceEqual(lowercase_  ,lowercase_						)

								# Checks everything loads correctly in the same way
								lowerCAmelCase__      :		Optional[int]    							=      tokenizer_r.from_pretrained(lowercase_						)
								lowerCAmelCase__      :		Union[str, Any]    							=      tokenizer_p.from_pretrained(lowercase_						)

								# Check special tokens are set accordingly on Rust and Python
								for key in tokenizer_pp.special_tokens_map:
									self.assertTrue(hasattr(lowercase_  ,lowercase_						)						)

								shutil.rmtree(lowercase_						)

								# Save tokenizer rust, legacy_format=True
								lowerCAmelCase__      :		Optional[int]    							=      tempfile.mkdtemp()

								lowerCAmelCase__      :		List[str]    							=      tokenizer_r.save_pretrained(lowercase_  ,legacy_format=lowercase_						)
								lowerCAmelCase__      :		List[Any]    							=      tokenizer_p.save_pretrained(lowercase_						)

								# Checks it save with the same files
								self.assertSequenceEqual(lowercase_  ,lowercase_						)

								# Checks everything loads correctly in the same way
								lowerCAmelCase__      :		Union[str, Any]    							=      tokenizer_r.from_pretrained(lowercase_						)
								lowerCAmelCase__      :		List[Any]    							=      tokenizer_p.from_pretrained(lowercase_						)

								# Check special tokens are set accordingly on Rust and Python
								for key in tokenizer_pp.special_tokens_map:
									self.assertTrue(hasattr(lowercase_  ,lowercase_						)						)

								shutil.rmtree(lowercase_						)

								# Save tokenizer rust, legacy_format=False
								lowerCAmelCase__      :		int    							=      tempfile.mkdtemp()

								lowerCAmelCase__      :		Tuple    							=      tokenizer_r.save_pretrained(lowercase_  ,legacy_format=lowercase_						)
								lowerCAmelCase__      :		Optional[Any]    							=      tokenizer_p.save_pretrained(lowercase_						)

								# Checks it saved the tokenizer.json file
								self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files						)						)

								# Checks everything loads correctly in the same way
								lowerCAmelCase__      :		int    							=      tokenizer_r.from_pretrained(lowercase_						)
								lowerCAmelCase__      :		str    							=      tokenizer_p.from_pretrained(lowercase_						)

								# Check special tokens are set accordingly on Rust and Python
								for key in tokenizer_pp.special_tokens_map:
									self.assertTrue(hasattr(lowercase_  ,lowercase_						)						)

								shutil.rmtree(lowercase_						)







					@require_torch
					def 			__lowerCAmelCase					(			self     :							List[Any]						):
						if not self.test_seqaseq:
							return

						lowerCAmelCase__      :		Union[str, Any]    							=      self.get_tokenizers()
						for tokenizer in tokenizers:
							with self.subTest(F'{tokenizer.__class__.__name__}'						):
								# Longer text that will definitely require truncation.
								lowerCAmelCase__      :		Tuple    							=      [
								    ''' UN Chief Says There Is No Military Solution in Syria''',
								    ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'''
								    ''' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'''
								    ''' will only worsen the violence and misery for millions of people.''',
								]
								lowerCAmelCase__      :		Union[str, Any]    							=      [
								    '''Şeful ONU declară că nu există o soluţie militară în Siria''',
								    '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'''
								    ''' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'''
								    ''' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
								]
								try:
									lowerCAmelCase__      :		List[str]    							=      tokenizer.prepare_seqaseq_batch(
									    src_texts=lowercase_  ,tgt_texts=lowercase_  ,max_length=3  ,max_target_length=1_0  ,return_tensors='''pt'''  ,src_lang='''eng_Latn'''  ,tgt_lang='''ron_Latn'''  ,)
								except NotImplementedError:
									return
								self.assertEqual(batch.input_ids.shape[1]  ,3						)
								self.assertEqual(batch.labels.shape[1]  ,1_0						)
								# max_target_length will default to max_length if not specified
								lowerCAmelCase__      :		Optional[Any]    							=      tokenizer.prepare_seqaseq_batch(
								    lowercase_  ,tgt_texts=lowercase_  ,max_length=3  ,return_tensors='''pt'''						)
								self.assertEqual(batch.input_ids.shape[1]  ,3						)
								self.assertEqual(batch.labels.shape[1]  ,3						)

								lowerCAmelCase__      :		Optional[Any]    							=      tokenizer.prepare_seqaseq_batch(
								    src_texts=lowercase_  ,max_length=3  ,max_target_length=1_0  ,return_tensors='''pt'''						)
								self.assertEqual(batch_encoder_only.input_ids.shape[1]  ,3						)
								self.assertEqual(batch_encoder_only.attention_mask.shape[1]  ,3						)
								self.assertNotIn('''decoder_input_ids'''  ,lowercase_						)







					@unittest.skip('''Unfortunately way too slow to build a BPE with SentencePiece.'''						)
					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						pass







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'						):
								lowerCAmelCase__      :		Optional[int]    							=      [AddedToken('''<special>'''  ,lstrip=lowercase_						)]

								lowerCAmelCase__      :		int    							=      self.rust_tokenizer_class.from_pretrained(
								    lowercase_  ,additional_special_tokens=lowercase_  ,**lowercase_						)
								lowerCAmelCase__      :		Union[str, Any]    							=      tokenizer_r.encode('''Hey this is a <special> token'''						)

								lowerCAmelCase__      :		int    							=      tokenizer_r.encode('''<special>'''  ,add_special_tokens=lowercase_						)[0]

								self.assertTrue(special_token_id in r_output						)

								if self.test_slow_tokenizer:
									lowerCAmelCase__      :		Tuple    							=      self.rust_tokenizer_class.from_pretrained(
									    lowercase_  ,additional_special_tokens=lowercase_  ,**lowercase_  ,)
									lowerCAmelCase__      :		Dict    							=      self.tokenizer_class.from_pretrained(
									    lowercase_  ,additional_special_tokens=lowercase_  ,**lowercase_						)

									lowerCAmelCase__      :		Optional[Any]    							=      tokenizer_p.encode('''Hey this is a <special> token'''						)

									lowerCAmelCase__      :		Union[str, Any]    							=      tokenizer_cr.encode('''Hey this is a <special> token'''						)

									self.assertEqual(lowercase_  ,lowercase_						)
									self.assertEqual(lowercase_  ,lowercase_						)
									self.assertTrue(special_token_id in p_output						)
									self.assertTrue(special_token_id in cr_output						)







@require_torch
@require_sentencepiece
@require_tokenizers
class 							SCREAMING_SNAKE_CASE   (						unittest.TestCase			):






					"""simple docstring"""



					lowercase__												=			"facebook/nllb-200-distilled-600M"
					lowercase__												=			[
					    " UN Chief Says There Is No Military Solution in Syria",
					    " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
					]
					lowercase__												=			[
					    "Şeful ONU declară că nu există o soluţie militară în Siria",
					    "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
					    " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
					    " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
					]
					lowercase__												=			[
					    256047,
					    16297,
					    134408,
					    8165,
					    248066,
					    14734,
					    950,
					    1135,
					    105721,
					    3573,
					    83,
					    27352,
					    108,
					    49486,
					    2,
					]







					@classmethod
					def 			__lowerCAmelCase					(			cls     :							Any						):
						lowerCAmelCase__      :		NllbTokenizer    							=      NllbTokenizer.from_pretrained(
						    cls.checkpoint_name  ,src_lang='''eng_Latn'''  ,tgt_lang='''ron_Latn'''						)
						lowerCAmelCase__      :		Any    							=      1
						return cls







					def 			__lowerCAmelCase					(			self     :							Any						):
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Arab''']  ,2_5_6_0_0_1						)
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Latn''']  ,2_5_6_0_0_2						)
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''fra_Latn''']  ,2_5_6_0_5_7						)







					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						lowerCAmelCase__      :		int    							=      self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
						self.assertListEqual(self.expected_src_tokens  ,lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Dict						):
						self.assertIn(lowercase_  ,self.tokenizer.all_special_ids						)
						# fmt: off
						lowerCAmelCase__      :		Optional[int]    							=      [RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
						# fmt: on

						lowerCAmelCase__      :		List[str]    							=      self.tokenizer.decode(lowercase_  ,skip_special_tokens=lowercase_						)
						lowerCAmelCase__      :		Dict    							=      self.tokenizer.decode(generated_ids[1:]  ,skip_special_tokens=lowercase_						)
						self.assertEqual(lowercase_  ,lowercase_						)
						self.assertNotIn(self.tokenizer.eos_token  ,lowercase_						)







					def 			__lowerCAmelCase					(			self     :							int						):
						lowerCAmelCase__      :		Union[str, Any]    							=      ['''this is gunna be a long sentence ''' * 2_0]
						assert isinstance(src_text[0]  ,lowercase_						)
						lowerCAmelCase__      :		int    							=      1_0
						lowerCAmelCase__      :		Any    							=      self.tokenizer(lowercase_  ,max_length=lowercase_  ,truncation=lowercase_						).input_ids[0]
						self.assertEqual(ids[-1]  ,2						)
						self.assertEqual(ids[0]  ,lowercase_						)
						self.assertEqual(len(lowercase_						)  ,lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']						)  ,[2_5_6_2_0_3, 3]						)







					def 			__lowerCAmelCase					(			self     :							List[Any]						):
						lowerCAmelCase__      :		int    							=      tempfile.mkdtemp()
						lowerCAmelCase__      :		Tuple    							=      self.tokenizer.fairseq_tokens_to_ids
						self.tokenizer.save_pretrained(lowercase_						)
						lowerCAmelCase__      :		Tuple    							=      NllbTokenizer.from_pretrained(lowercase_						)
						self.assertDictEqual(new_tok.fairseq_tokens_to_ids  ,lowercase_						)







					@require_torch
					def 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		Any    							=      self.tokenizer(
						    self.src_text  ,text_target=self.tgt_text  ,padding=lowercase_  ,truncation=lowercase_  ,max_length=len(self.expected_src_tokens						)  ,return_tensors='''pt'''  ,)
						lowerCAmelCase__      :		Optional[Any]    							=      shift_tokens_right(
						    batch['''labels''']  ,self.tokenizer.pad_token_id  ,self.tokenizer.lang_code_to_id['''ron_Latn''']						)

						self.assertIsInstance(lowercase_  ,lowercase_						)

						self.assertEqual((2, 1_5)  ,batch.input_ids.shape						)
						self.assertEqual((2, 1_5)  ,batch.attention_mask.shape						)
						lowerCAmelCase__      :		Dict    							=      batch.input_ids.tolist()[0]
						self.assertListEqual(self.expected_src_tokens  ,lowercase_						)
						self.assertEqual(lowercase_  ,batch.decoder_input_ids[0, 0]						)  # EOS
						# Test that special tokens are reset
						self.assertEqual(self.tokenizer.prefix_tokens  ,[EN_CODE]						)
						self.assertEqual(self.tokenizer.suffix_tokens  ,[self.tokenizer.eos_token_id]						)







					def 			__lowerCAmelCase					(			self     :							List[Any]						):
						lowerCAmelCase__      :		List[Any]    							=      self.tokenizer(self.src_text  ,padding=lowercase_  ,truncation=lowercase_  ,max_length=3  ,return_tensors='''pt'''						)
						lowerCAmelCase__      :		int    							=      self.tokenizer(
						    text_target=self.tgt_text  ,padding=lowercase_  ,truncation=lowercase_  ,max_length=1_0  ,return_tensors='''pt'''						)
						lowerCAmelCase__      :		List[str]    							=      targets['''input_ids''']
						lowerCAmelCase__      :		Tuple    							=      shift_tokens_right(
						    lowercase_  ,self.tokenizer.pad_token_id  ,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]  ,)

						self.assertEqual(batch.input_ids.shape[1]  ,3						)
						self.assertEqual(batch.decoder_input_ids.shape[1]  ,1_0						)







					@require_torch
					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Optional[int]    							=      self.tokenizer._build_translation_inputs(
						    '''A test'''  ,return_tensors='''pt'''  ,src_lang='''eng_Latn'''  ,tgt_lang='''fra_Latn'''						)

						self.assertEqual(
						    nested_simplify(lowercase_						)  ,{
						        # A, test, EOS, en_XX
						        '''input_ids''': [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
						        '''attention_mask''': [[1, 1, 1, 1]],
						        # ar_AR
						        '''forced_bos_token_id''': 2_5_6_0_5_7,
						    }  ,)







					@require_torch
					def 			__lowerCAmelCase					(			self     :							int						):
						lowerCAmelCase__      :		Optional[Any]    							=      True
						lowerCAmelCase__      :		Tuple    							=      self.tokenizer(
						    '''UN Chief says there is no military solution in Syria'''  ,src_lang='''eng_Latn'''  ,tgt_lang='''fra_Latn'''						)
						self.assertEqual(
						    inputs.input_ids  ,[1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7]						)

						lowerCAmelCase__      :		Optional[int]    							=      False
						lowerCAmelCase__      :		str    							=      self.tokenizer(
						    '''UN Chief says there is no military solution in Syria'''  ,src_lang='''eng_Latn'''  ,tgt_lang='''fra_Latn'''						)
						self.assertEqual(
						    inputs.input_ids  ,[2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2]						)







"""simple docstring"""





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase

def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__							,lowerCAmelCase__      :		Dict    							=      analyze_text(A_					)
	lowerCAmelCase__      :		Any    							=      list(''' ''' + ascii_lowercase					)
	# what is our total sum of probabilities.
	lowerCAmelCase__      :		Optional[Any]    							=      sum(single_char_strings.values()					)

	# one length string
	lowerCAmelCase__      :		int    							=      0
	# for each alpha we go in our dict and if it is in it we calculate entropy
	for ch in my_alphas:
		if ch in single_char_strings:
			lowerCAmelCase__      :		Union[str, Any]    							=      single_char_strings[ch]
			lowerCAmelCase__      :		Dict    							=      my_str / all_sum
			my_fir_sum += prob * math.loga(A_					)  # entropy formula.

    # print entropy
	print(f'{round(-1 * my_fir_sum					):.1f}'					)

	# two len string
	lowerCAmelCase__      :		List[Any]    							=      sum(two_char_strings.values()					)
	lowerCAmelCase__      :		Optional[int]    							=      0
	# for each alpha (two in size) calculate entropy.
	for cha in my_alphas:
		for cha in my_alphas:
			lowerCAmelCase__      :		int    							=      cha + cha
			if sequence in two_char_strings:
				lowerCAmelCase__      :		Optional[Any]    							=      two_char_strings[sequence]
				lowerCAmelCase__      :		int    							=      int(A_					) / all_sum
				my_sec_sum += prob * math.loga(A_					)

    # print second entropy
	print(f'{round(-1 * my_sec_sum					):.1f}'					)

	# print the difference between them
	print(f'{round((-1 * my_sec_sum) - (-1 * my_fir_sum)					):.1f}'					)

def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		List[str]    							=      Counter()  # type: ignore
	lowerCAmelCase__      :		Optional[int]    							=      Counter()  # type: ignore
	single_char_strings[text[-1]] += 1

	# first case when we have space at start.
	two_char_strings[" " + text[0]] += 1
	for i in range(0		,	len(A_					) - 1					):
		single_char_strings[text[i]] += 1
		two_char_strings[text[i : i + 2]] += 1
	return single_char_strings, two_char_strings

def     __SCREAMING_SNAKE_CASE    ( ):
	import doctest

	doctest.testmod()
	# text = (
	#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
	#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
	#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
	#     "beloved evident through no service elderly is. Blind there if every no so "
	#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
	#     "of message cottage windows do besides against uncivil.  Delightful "
	#     "unreserved impossible few estimating men favourable see entreaties. She "
	#     "propriety immediate was improving. He or entrance humoured likewise "
	#     "moderate. Much nor game son say feel. Fat make met can must form into "
	#     "gate. Me we offending prevailed discovery. "
	# )

	# calculate_prob(text)


if __name__ == "__main__":
							main()




