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





   """simple docstring"""




   lowerCAmelCase      :    Tuple  			=   MODEL_FOR_MASKED_LM_MAPPING
   lowerCAmelCase      :    Optional[int]  			=   TF_MODEL_FOR_MASKED_LM_MAPPING



   def   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    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   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  top_k=2		,  framework='''tf'''							)
    _UpperCamelCase:     Optional[int]							= unmasker('''My name is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {'''sequence''': '''My name is grouped''', '''score''': 2.1E-05, '''token''': 38_015, '''token_str''': ''' grouped'''},
            {'''sequence''': '''My name is accuser''', '''score''': 2.1E-05, '''token''': 25_506, '''token_str''': ''' accuser'''},
        ]		,  )

    _UpperCamelCase:     Dict							= unmasker('''The largest city in France is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {
                '''sequence''': '''The largest city in France is grouped''',
                '''score''': 2.1E-05,
                '''token''': 38_015,
                '''token_str''': ''' grouped''',
            },
            {
                '''sequence''': '''The largest city in France is accuser''',
                '''score''': 2.1E-05,
                '''token''': 25_506,
                '''token_str''': ''' accuser''',
            },
        ]		,  )

    _UpperCamelCase:     Tuple							= unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 13_606, '''token_str''': ''' Clara'''},
            {'''sequence''': '''My name is Patrick''', '''score''': 2E-05, '''token''': 3_499, '''token_str''': ''' Patrick'''},
            {'''sequence''': '''My name is Te''', '''score''': 1.9E-05, '''token''': 2_941, '''token_str''': ''' Te'''},
        ]		,  )



   @require_torch
   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  top_k=2		,  framework='''pt'''							)

    _UpperCamelCase:     Dict							= unmasker('''My name is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {'''sequence''': '''My name is Maul''', '''score''': 2.2E-05, '''token''': 35_676, '''token_str''': ''' Maul'''},
            {'''sequence''': '''My name isELS''', '''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS'''},
        ]		,  )

    _UpperCamelCase:     int							= unmasker('''The largest city in France is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {
                '''sequence''': '''The largest city in France is Maul''',
                '''score''': 2.2E-05,
                '''token''': 35_676,
                '''token_str''': ''' Maul''',
            },
            {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS'''},
        ]		,  )

    _UpperCamelCase:     List[str]							= unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3							)
    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            {'''sequence''': '''My name is Patrick''', '''score''': 2.1E-05, '''token''': 3_499, '''token_str''': ''' Patrick'''},
            {'''sequence''': '''My name is Te''', '''score''': 2E-05, '''token''': 2_941, '''token_str''': ''' Te'''},
            {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 13_606, '''token_str''': ''' Clara'''},
        ]		,  )

    _UpperCamelCase:     List[Any]							= unmasker('''My name is <mask> <mask>'''		,  top_k=2							)

    self.assertEqual(
        nested_simplify(_lowercase		,  decimals=6							)		,  [
            [
                {
                    '''score''': 2.2E-05,
                    '''token''': 35_676,
                    '''token_str''': ''' Maul''',
                    '''sequence''': '''<s>My name is Maul<mask></s>''',
                },
                {'''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
            ],
            [
                {
                    '''score''': 2.2E-05,
                    '''token''': 35_676,
                    '''token_str''': ''' Maul''',
                    '''sequence''': '''<s>My name is<mask> Maul</s>''',
                },
                {'''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
            ],
        ]		,  )



   @require_torch_gpu
   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    _UpperCamelCase:     str							= pipeline('''fill-mask'''		,  model='''hf-internal-testing/tiny-random-distilbert'''		,  device=0		,  framework='''pt'''							)

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

    _UpperCamelCase:     Union[str, Any]							= 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(_lowercase		,  _lowercase							)



   @slow
   @require_torch
   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     int							= pipeline(task='''fill-mask'''		,  model='''distilroberta-base'''		,  top_k=2		,  framework='''pt'''							)
    self.run_large_test(_lowercase							)



   @slow
   @require_tf
   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     str							= pipeline(task='''fill-mask'''		,  model='''distilroberta-base'''		,  top_k=2		,  framework='''tf'''							)
    self.run_large_test(_lowercase							)



   def   lowerCAmelCase						(	self					:  Union[str, Any]		,  _lowercase					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     Any							= unmasker('''My name is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase							)		,  [
            {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 610, '''token_str''': ''' John'''},
            {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1_573, '''token_str''': ''' Chris'''},
        ]		,  )
    _UpperCamelCase:     Any							= unmasker('''The largest city in France is <mask>'''							)
    self.assertEqual(
        nested_simplify(_lowercase							)		,  [
            {
                '''sequence''': '''The largest city in France is Paris''',
                '''score''': 0.251,
                '''token''': 2_201,
                '''token_str''': ''' Paris''',
            },
            {
                '''sequence''': '''The largest city in France is Lyon''',
                '''score''': 0.214,
                '''token''': 12_790,
                '''token_str''': ''' Lyon''',
            },
        ]		,  )

    _UpperCamelCase:     Optional[int]							= unmasker('''My name is <mask>'''		,  targets=[''' Patrick''', ''' Clara''', ''' Teven''']		,  top_k=3							)
    self.assertEqual(
        nested_simplify(_lowercase							)		,  [
            {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 3_499, '''token_str''': ''' Patrick'''},
            {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 13_606, '''token_str''': ''' Clara'''},
            {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2_941, '''token_str''': ''' Te'''},
        ]		,  )



   @require_torch
   def   lowerCAmelCase						(	self					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  framework='''pt'''							)
    _UpperCamelCase:     Dict							= None
    _UpperCamelCase:     str							= None
    self.run_pipeline_test(_lowercase		,  []							)



   @require_tf
   def   lowerCAmelCase						(	self					:  Union[str, Any]							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= pipeline(task='''fill-mask'''		,  model='''sshleifer/tiny-distilroberta-base'''		,  framework='''tf'''							)
    _UpperCamelCase:     Union[str, Any]							= None
    _UpperCamelCase:     Any							= None
    self.run_pipeline_test(_lowercase		,  []							)



   def   lowerCAmelCase						(	self					:  Tuple		,  _lowercase					:  Dict		,  _lowercase					:  Any		,  _lowercase					:  List[str]							):



    """simple docstring"""



    if tokenizer is None or tokenizer.mask_token_id is None:
     self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)'''							)

    _UpperCamelCase:     Any							= FillMaskPipeline(model=_lowercase		,  tokenizer=_lowercase							)
    _UpperCamelCase:     Any							= [
        f"""This is another {tokenizer.mask_token} test""",
    ]
    return fill_masker, examples



   def   lowerCAmelCase						(	self					:  List[str]		,  _lowercase					:  Optional[Any]		,  _lowercase					:  List[str]							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= fill_masker.tokenizer
    _UpperCamelCase:     Dict							= fill_masker.model

    _UpperCamelCase:     Union[str, Any]							= fill_masker(
        f"""This is a {tokenizer.mask_token}"""		,  )
    self.assertEqual(
        _lowercase		,  [
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
        ]		,  )

    _UpperCamelCase:     Union[str, Any]							= fill_masker([f"""This is a {tokenizer.mask_token}"""]							)
    self.assertEqual(
        _lowercase		,  [
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
        ]		,  )

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

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

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



   def   lowerCAmelCase						(	self					:  Any		,  _lowercase					:  int		,  _lowercase					:  List[Any]							):



    """simple docstring"""



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

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

    # Score equivalence
    _UpperCamelCase:     Union[str, Any]							= fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=_lowercase							)
    _UpperCamelCase:     List[Any]							= [top_mask['''token_str'''] for top_mask in outputs]
    _UpperCamelCase:     List[Any]							= [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(_lowercase							) == set(_lowercase							):
     _UpperCamelCase:     str							= fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=_lowercase							)
     _UpperCamelCase:     Any							= [top_mask['''score'''] for top_mask in unmasked_targets]
     self.assertEqual(nested_simplify(_lowercase							)		,  nested_simplify(_lowercase							)							)

    # Raises with invalid
    with self.assertRaises(_lowercase							):
     _UpperCamelCase:     Optional[Any]							= 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(_lowercase							):
      _UpperCamelCase:     List[Any]							= fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=['''''']							)
     with self.assertRaises(_lowercase							):
      _UpperCamelCase:     Optional[Any]							= fill_masker(f"""This is a {tokenizer.mask_token}"""		,  targets=''''''							)



   def   lowerCAmelCase						(	self					:  Tuple		,  _lowercase					:  Any		,  _lowercase					:  int							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= FillMaskPipeline(model=_lowercase		,  tokenizer=_lowercase		,  top_k=2							)
    _UpperCamelCase:     Optional[Any]							= fill_masker(f"""This is a {tokenizer.mask_token}"""							)
    self.assertEqual(
        _lowercase		,  [
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
        ]		,  )

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



   def   lowerCAmelCase						(	self					:  Any		,  _lowercase					:  str		,  _lowercase					:  str							):



    """simple docstring"""



    _UpperCamelCase:     str							= tokenizer.get_vocab()
    _UpperCamelCase:     Optional[int]							= FillMaskPipeline(model=_lowercase		,  tokenizer=_lowercase							)

    # top_k=2, ntargets=3
    _UpperCamelCase:     Optional[int]							= sorted(vocab.keys()							)[:3]
    _UpperCamelCase:     List[str]							= fill_masker(f"""This is a {tokenizer.mask_token}"""		,  top_k=2		,  targets=_lowercase							)

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



   def   lowerCAmelCase						(	self					:  int		,  _lowercase					:  Dict		,  _lowercase					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= FillMaskPipeline(model=_lowercase		,  tokenizer=_lowercase							)
    _UpperCamelCase:     Optional[Any]							= tokenizer.get_vocab()
    # String duplicates + id duplicates
    _UpperCamelCase:     Tuple							= sorted(vocab.keys()							)[:3]
    _UpperCamelCase:     Any							= [targets[0], targets[1], targets[0], targets[2], targets[1]]
    _UpperCamelCase:     List[str]							= fill_masker(f"""My name is {tokenizer.mask_token}"""		,  targets=_lowercase		,  top_k=10							)

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



   def   lowerCAmelCase						(	self					:  Dict		,  _lowercase					:  List[str]		,  _lowercase					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= FillMaskPipeline(model=_lowercase		,  tokenizer=_lowercase							)

    _UpperCamelCase:     Dict							= fill_masker(
        f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""		,  top_k=2							)
    self.assertEqual(
        _lowercase		,  [
            [
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            ],
            [
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            ],
            [
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
                {'''sequence''': ANY(_lowercase							), '''score''': ANY(_lowercase							), '''token''': ANY(_lowercase							), '''token_str''': ANY(_lowercase							)},
            ],
        ]		,  )
def       lowerCAmelCase_     (		lowercase:							float		)    ->				float:







 '''simple docstring'''

 if edge <= 0 or not isinstance(lowercase  ,					lowercase		):
  raise ValueError('''Length must be a positive.'''		)
 return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2)




def       lowerCAmelCase_     (		lowercase:							float		)    ->				float:







 '''simple docstring'''

 if edge <= 0 or not isinstance(lowercase  ,					lowercase		):
  raise ValueError('''Length must be a positive.'''		)
 return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3)


if __name__ == "__main__":
  import doctest

  doctest.testmod()