






import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY





@is_pipeline_test
class     SCREAMING_SNAKE_CASE					(			unittest.TestCase       ):





							"""simple docstring"""

							A_    	=       MODEL_FOR_MASKED_LM_MAPPING
							A_    	=       TF_MODEL_FOR_MASKED_LM_MAPPING

							def    __A			(	self: str )     ->					Union[str, Any]:
												super().tearDown()
												# clean-up as much as possible GPU memory occupied by PyTorch
												gc.collect()
												if is_torch_available():
																	import torch

																	torch.cuda.empty_cache()

							@require_tf
							def    __A			(	self: List[Any] )     ->					Tuple:
												_A										=			pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  top_k=2		,  framework='''tf''' )
												_A										=			unmasker('''My name is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {'''sequence''': '''My name is grouped''', '''score''': 2.1e-05, '''token''': 3_80_15, '''token_str''': ''' grouped'''},
												        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-05, '''token''': 2_55_06, '''token_str''': ''' accuser'''},
												    ]		,  )

												_A										=			unmasker('''The largest city in France is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {
												            '''sequence''': '''The largest city in France is grouped''',
												            '''score''': 2.1e-05,
												            '''token''': 3_80_15,
												            '''token_str''': ''' grouped''',
												        },
												        {
												            '''sequence''': '''The largest city in France is accuser''',
												            '''score''': 2.1e-05,
												            '''token''': 2_55_06,
												            '''token_str''': ''' accuser''',
												        },
												    ]		,  )

												_A										=			unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3 )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
												        {'''sequence''': '''My name is Patrick''', '''score''': 2e-05, '''token''': 34_99, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Te''', '''score''': 1.9e-05, '''token''': 29_41, '''token_str''': ''' Te'''},
												    ]		,  )

							@require_torch
							def    __A			(	self: Union[str, Any] )     ->					Union[str, Any]:
												_A										=			pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  top_k=2		,  framework='''pt''' )

												_A										=			unmasker('''My name is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {'''sequence''': '''My name is Maul''', '''score''': 2.2e-05, '''token''': 3_56_76, '''token_str''': ''' Maul'''},
												        {'''sequence''': '''My name isELS''', '''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS'''},
												    ]		,  )

												_A										=			unmasker('''The largest city in France is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {
												            '''sequence''': '''The largest city in France is Maul''',
												            '''score''': 2.2e-05,
												            '''token''': 3_56_76,
												            '''token_str''': ''' Maul''',
												        },
												        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS'''},
												    ]		,  )

												_A										=			unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3 )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-05, '''token''': 34_99, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Te''', '''score''': 2e-05, '''token''': 29_41, '''token_str''': ''' Te'''},
												        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
												    ]		,  )

												_A										=			unmasker('''My name is <mask> <mask>'''		,  top_k=2 )

												self.assertEqual(
												    nested_simplify(lowerCamelCase__		,  decimals=6 )		,  [
												        [
												            {
												                '''score''': 2.2e-05,
												                '''token''': 3_56_76,
												                '''token_str''': ''' Maul''',
												                '''sequence''': '''<s>My name is Maul<mask></s>''',
												            },
												            {'''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
												        ],
												        [
												            {
												                '''score''': 2.2e-05,
												                '''token''': 3_56_76,
												                '''token_str''': ''' Maul''',
												                '''sequence''': '''<s>My name is<mask> Maul</s>''',
												            },
												            {'''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
												        ],
												    ]		,  )

							@require_torch_gpu
							def    __A			(	self: Tuple )     ->					List[str]:
												_A										=			pipeline('''fill-mask'''		,  model='''hf-internal-testing/tiny-random-distilbert'''		,  device=0		,  framework='''pt''' )

												# convert model to fp16
												pipe.model.half()

												_A										=			pipe('''Paris is the [MASK] of France.''' )
												# We actually don't care about the result, we just want to make sure
												# it works, meaning the float16 tensor got casted back to float32
												# for postprocessing.
												self.assertIsInstance(lowerCamelCase__		,  lowerCamelCase__ )

							@slow
							@require_torch
							def    __A			(	self: Optional[int] )     ->					int:
												_A										=			pipeline(task='''fill-mask'''		,  model='''distilroberta-base'''		,  top_k=2		,  framework='''pt''' )
												self.run_large_test(lowerCamelCase__ )

							@slow
							@require_tf
							def    __A			(	self: int )     ->					Optional[Any]:
												_A										=			pipeline(task='''fill-mask'''		,  model='''distilroberta-base'''		,  top_k=2		,  framework='''tf''' )
												self.run_large_test(lowerCamelCase__ )

							def    __A			(	self: Union[str, Any]		,  __A: Any )     ->					List[str]:
												_A										=			unmasker('''My name is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__ )		,  [
												        {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 6_10, '''token_str''': ''' John'''},
												        {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 15_73, '''token_str''': ''' Chris'''},
												    ]		,  )
												_A										=			unmasker('''The largest city in France is <mask>''' )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__ )		,  [
												        {
												            '''sequence''': '''The largest city in France is Paris''',
												            '''score''': 0.251,
												            '''token''': 22_01,
												            '''token_str''': ''' Paris''',
												        },
												        {
												            '''sequence''': '''The largest city in France is Lyon''',
												            '''score''': 0.214,
												            '''token''': 1_27_90,
												            '''token_str''': ''' Lyon''',
												        },
												    ]		,  )

												_A										=			unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3 )
												self.assertEqual(
												    nested_simplify(lowerCamelCase__ )		,  [
												        {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 34_99, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
												        {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 29_41, '''token_str''': ''' Te'''},
												    ]		,  )

							@require_torch
							def    __A			(	self: Union[str, Any] )     ->					Optional[Any]:
												_A										=			pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  framework='''pt''' )
												_A										=			None
												_A										=			None
												self.run_pipeline_test(lowerCamelCase__		,  [] )

							@require_tf
							def    __A			(	self: Optional[Any] )     ->					Union[str, Any]:
												_A										=			pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  framework='''tf''' )
												_A										=			None
												_A										=			None
												self.run_pipeline_test(lowerCamelCase__		,  [] )

							def    __A			(	self: List[str]		,  __A: List[Any]		,  __A: Optional[int]		,  __A: List[Any] )     ->					Union[str, Any]:
												if tokenizer is None or tokenizer.mask_token_id is None:
																	self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)''' )

												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )
												_A										=			[
												    f"""This is another {tokenizer.mask_token} test""",
												]
												return fill_masker, examples

							def    __A			(	self: Tuple		,  __A: int		,  __A: Optional[int] )     ->					Union[str, Any]:
												_A										=			fill_masker.tokenizer
												_A										=			fill_masker.model

												_A										=			fill_masker(
												    f"""This is a {tokenizer.mask_token}"""		,  )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )

												_A										=			fill_masker([f"""This is a {tokenizer.mask_token}"""] )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )

												_A										=			fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        [
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        ],
												        [
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        ],
												    ]		,  )

												with self.assertRaises(lowerCamelCase__ ):
																	fill_masker([None] )
												# No mask_token is not supported
												with self.assertRaises(lowerCamelCase__ ):
																	fill_masker('''This is''' )

												self.run_test_top_k(lowerCamelCase__		,  lowerCamelCase__ )
												self.run_test_targets(lowerCamelCase__		,  lowerCamelCase__ )
												self.run_test_top_k_targets(lowerCamelCase__		,  lowerCamelCase__ )
												self.fill_mask_with_duplicate_targets_and_top_k(lowerCamelCase__		,  lowerCamelCase__ )
												self.fill_mask_with_multiple_masks(lowerCamelCase__		,  lowerCamelCase__ )

							def    __A			(	self: Union[str, Any]		,  __A: Any		,  __A: Optional[Any] )     ->					Union[str, Any]:
												_A										=			tokenizer.get_vocab()
												_A										=			sorted(vocab.keys() )[:2]
												# Pipeline argument
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__		,  targets=lowerCamelCase__ )
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}""" )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )
												_A										=			{vocab[el] for el in targets}
												self.assertEqual({el['''token'''] for el in outputs}		,  lowerCamelCase__ )
												_A										=			[tokenizer.decode([x] ) for x in target_ids]
												self.assertEqual({el['''token_str'''] for el in outputs}		,  set(lowerCamelCase__ ) )

												# Call argument
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=lowerCamelCase__ )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )
												_A										=			{vocab[el] for el in targets}
												self.assertEqual({el['''token'''] for el in outputs}		,  lowerCamelCase__ )
												_A										=			[tokenizer.decode([x] ) for x in target_ids]
												self.assertEqual({el['''token_str'''] for el in outputs}		,  set(lowerCamelCase__ ) )

												# Score equivalence
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=lowerCamelCase__ )
												_A										=			[top_mask["token_str"] for top_mask in outputs]
												_A										=			[top_mask["score"] for top_mask in outputs]

												# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
												if set(lowerCamelCase__ ) == set(lowerCamelCase__ ):
																	_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=lowerCamelCase__ )
																	_A										=			[top_mask["score"] for top_mask in unmasked_targets]
																	self.assertEqual(nested_simplify(lowerCamelCase__ )		,  nested_simplify(lowerCamelCase__ ) )

												# Raises with invalid
												with self.assertRaises(lowerCamelCase__ ):
																	_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=[] )
												# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
												if "" not in tokenizer.get_vocab():
																	with self.assertRaises(lowerCamelCase__ ):
																						_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=[''''''] )
																	with self.assertRaises(lowerCamelCase__ ):
																						_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets='''''' )

							def    __A			(	self: Tuple		,  __A: Union[str, Any]		,  __A: str )     ->					int:
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__		,  top_k=2 )
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}""" )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )

												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  top_k=2 )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												    ]		,  )
												self.assertEqual(nested_simplify(lowerCamelCase__ )		,  nested_simplify(lowerCamelCase__ ) )

							def    __A			(	self: Union[str, Any]		,  __A: int		,  __A: Tuple )     ->					Optional[Any]:
												_A										=			tokenizer.get_vocab()
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )

												# top_k=2, ntargets=3
												_A										=			sorted(vocab.keys() )[:3]
												_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  top_k=2		,  targets=lowerCamelCase__ )

												# If we use the most probably targets, and filter differently, we should still
												# have the same results
												_A										=			[el["token_str"] for el in sorted(lowerCamelCase__		,  key=lambda __A : x["score"]		,  reverse=lowerCamelCase__ )]
												# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
												if set(lowerCamelCase__ ).issubset(lowerCamelCase__ ):
																	_A										=			fill_masker(f"""This is a {tokenizer.mask_token}"""		,  top_k=3		,  targets=lowerCamelCase__ )
																	# They should yield exactly the same result
																	self.assertEqual(nested_simplify(lowerCamelCase__ )		,  nested_simplify(lowerCamelCase__ ) )

							def    __A			(	self: List[Any]		,  __A: Optional[int]		,  __A: Tuple )     ->					Tuple:
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )
												_A										=			tokenizer.get_vocab()
												# String duplicates + id duplicates
												_A										=			sorted(vocab.keys() )[:3]
												_A										=			[targets[0], targets[1], targets[0], targets[2], targets[1]]
												_A										=			fill_masker(f"""My name is {tokenizer.mask_token}"""		,  targets=lowerCamelCase__		,  top_k=10 )

												# The target list contains duplicates, so we can't output more
												# than them
												self.assertEqual(len(lowerCamelCase__ )		,  3 )



							def    __A			(	self: Any		,  __A: int		,  __A: Dict )     ->					Union[str, Any]:
												_A										=			FillMaskPipeline(model=lowerCamelCase__		,  tokenizer=lowerCamelCase__ )

												_A										=			fill_masker(
												    f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""		,  top_k=2 )
												self.assertEqual(
												    lowerCamelCase__		,  [
												        [
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        ],
												        [
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        ],
												        [
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												            {'''sequence''': ANY(lowerCamelCase__ ), '''score''': ANY(lowerCamelCase__ ), '''token''': ANY(lowerCamelCase__ ), '''token_str''': ANY(lowerCamelCase__ )},
												        ],
												    ]		,  )




def 		snake_case__	(		lowercase							,				lowercase					):

   if density <= 0:
      raise ValueError("Impossible fluid density"					)
   if bulk_modulus <= 0:
      raise ValueError("Impossible bulk modulus"					)

   return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
 import doctest

 doctest.testmod()