





"""simple docstring"""





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

      '''simple docstring'''



      _A     :       Union[str, Any]         =       MODEL_FOR_MASKED_LM_MAPPING
      _A     :       Optional[int]         =       TF_MODEL_FOR_MASKED_LM_MAPPING

      def       A_					(							self       :      Tuple ):


        '''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       A_					(							self       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						pipeline(task='''fill-mask'''						,				model='''sshleifer/tiny-distilroberta-base'''						,				top_k=2						,				framework='''tf''' )
        __UpperCAmelCase    :						Union[str, Any]       =						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    :						int       =						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    :						List[Any]       =						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       A_					(							self       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						pipeline(task='''fill-mask'''						,				model='''sshleifer/tiny-distilroberta-base'''						,				top_k=2						,				framework='''pt''' )

        __UpperCAmelCase    :						Optional[int]       =						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    :						str       =						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    :						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       A_					(							self       :      List[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						pipeline('''fill-mask'''						,				model='''hf-internal-testing/tiny-random-distilbert'''						,				device=0						,				framework='''pt''' )

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

        __UpperCAmelCase    :						Dict       =						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       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						pipeline(task='''fill-mask'''						,				model='''distilroberta-base'''						,				top_k=2						,				framework='''pt''' )
        self.run_large_test(__lowercase )

      @slow
      @require_tf
      def       A_					(							self       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						pipeline(task='''fill-mask'''						,				model='''distilroberta-base'''						,				top_k=2						,				framework='''tf''' )
        self.run_large_test(__lowercase )

      def       A_					(							self       :      Union[str, Any]						,				__lowercase       :      Optional[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						List[str]       =						unmasker('''My name is <mask>''' )
        self.assertEqual(
            nested_simplify(__lowercase )						,				[
                {'''sequence''': '''My name is John''', '''score''': 0.0_0_8, '''token''': 610, '''token_str''': ''' John'''},
                {'''sequence''': '''My name is Chris''', '''score''': 0.0_0_7, '''token''': 1_573, '''token_str''': ''' Chris'''},
            ]						,				)
        __UpperCAmelCase    :						Dict       =						unmasker('''The largest city in France is <mask>''' )
        self.assertEqual(
            nested_simplify(__lowercase )						,				[
                {
                    '''sequence''': '''The largest city in France is Paris''',
                    '''score''': 0.2_5_1,
                    '''token''': 2_201,
                    '''token_str''': ''' Paris''',
                },
                {
                    '''sequence''': '''The largest city in France is Lyon''',
                    '''score''': 0.2_1_4,
                    '''token''': 12_790,
                    '''token_str''': ''' Lyon''',
                },
            ]						,				)

        __UpperCAmelCase    :						Tuple       =						unmasker('''My name is <mask>'''						,				targets=[''' Patrick''', ''' Clara''', ''' Teven''']						,				top_k=3 )
        self.assertEqual(
            nested_simplify(__lowercase )						,				[
                {'''sequence''': '''My name is Patrick''', '''score''': 0.0_0_5, '''token''': 3_499, '''token_str''': ''' Patrick'''},
                {'''sequence''': '''My name is Clara''', '''score''': 0.0_0_0, '''token''': 13_606, '''token_str''': ''' Clara'''},
                {'''sequence''': '''My name is Te''', '''score''': 0.0_0_0, '''token''': 2_941, '''token_str''': ''' Te'''},
            ]						,				)

      @require_torch
      def       A_					(							self       :      Tuple ):


        '''simple docstring'''




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

      @require_tf
      def       A_					(							self       :      List[Any] ):


        '''simple docstring'''




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

      def       A_					(							self       :      Optional[int]						,				__lowercase       :      Union[str, Any]						,				__lowercase       :      Dict						,				__lowercase       :      Tuple ):


        '''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    :						int       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase )
        __UpperCAmelCase    :						int       =						[
            f'''This is another {tokenizer.mask_token} test''',
        ]
        return fill_masker, examples

      def       A_					(							self       :      Tuple						,				__lowercase       :      Tuple						,				__lowercase       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						str       =						fill_masker.tokenizer
        __UpperCAmelCase    :						Optional[int]       =						fill_masker.model

        __UpperCAmelCase    :						Tuple       =						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    :						int       =						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    :						Optional[Any]       =						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       A_					(							self       :      Tuple						,				__lowercase       :      List[Any]						,				__lowercase       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						tokenizer.get_vocab()
        __UpperCAmelCase    :						Optional[int]       =						sorted(vocab.keys() )[:2]
        # Pipeline argument
        __UpperCAmelCase    :						Optional[int]       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase						,				targets=__lowercase )
        __UpperCAmelCase    :						Dict       =						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    :						Optional[Any]       =						[tokenizer.decode([x] ) for x in target_ids]
        self.assertEqual({el['''token_str'''] for el in outputs}						,				set(__lowercase ) )

        # Call argument
        __UpperCAmelCase    :						Optional[int]       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase )
        __UpperCAmelCase    :						Any       =						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    :						Tuple       =						[tokenizer.decode([x] ) for x in target_ids]
        self.assertEqual({el['''token_str'''] for el in outputs}						,				set(__lowercase ) )

        # Score equivalence
        __UpperCAmelCase    :						Dict       =						fill_masker(f'''This is a {tokenizer.mask_token}'''						,				targets=__lowercase )
        __UpperCAmelCase    :						Union[str, Any]       =						[top_mask['''token_str'''] for top_mask in outputs]
        __UpperCAmelCase    :						int       =						[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    :						Union[str, Any]       =						fill_masker(f'''This is a {tokenizer.mask_token}'''						,				targets=__lowercase )
          __UpperCAmelCase    :						List[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[int]       =						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    :						Tuple       =						fill_masker(f'''This is a {tokenizer.mask_token}'''						,				targets=[''''''] )
          with self.assertRaises(__lowercase ):
            __UpperCAmelCase    :						int       =						fill_masker(f'''This is a {tokenizer.mask_token}'''						,				targets='''''' )

      def       A_					(							self       :      str						,				__lowercase       :      Optional[int]						,				__lowercase       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase						,				top_k=2 )
        __UpperCAmelCase    :						Tuple       =						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]       =						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       A_					(							self       :      List[str]						,				__lowercase       :      Optional[Any]						,				__lowercase       :      Optional[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						tokenizer.get_vocab()
        __UpperCAmelCase    :						Any       =						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    :						Union[str, Any]       =						[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    :						Optional[Any]       =						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       A_					(							self       :      Any						,				__lowercase       :      str						,				__lowercase       :      Any ):


        '''simple docstring'''




        __UpperCAmelCase    :						str       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase )
        __UpperCAmelCase    :						str       =						tokenizer.get_vocab()
        # String duplicates + id duplicates
        __UpperCAmelCase    :						int       =						sorted(vocab.keys() )[:3]
        __UpperCAmelCase    :						int       =						[targets[0], targets[1], targets[0], targets[2], targets[1]]
        __UpperCAmelCase    :						int       =						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       A_					(							self       :      int						,				__lowercase       :      Optional[int]						,				__lowercase       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						List[str]       =						FillMaskPipeline(model=__lowercase						,				tokenizer=__lowercase )

        __UpperCAmelCase    :						str       =						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 )},
                ],
            ]						,				)






"""simple docstring"""





def       lowerCamelCase_       (   UpperCAmelCase_  )						->float:





  """simple docstring"""


  return 10 - x * x


def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  )						->float:





  """simple docstring"""


  if equation(UpperCAmelCase_  ) * equation(UpperCAmelCase_  ) >= 0:
    raise ValueError('''Wrong space!'''  )

  __UpperCAmelCase    :						Tuple       =						a
  while (b - a) >= 0.01:
    # Find middle point
    __UpperCAmelCase    :						List[str]       =						(a + b) / 2
    # Check if middle point is root
    if equation(UpperCAmelCase_  ) == 0.0:
      break
    # Decide the side to repeat the steps
    if equation(UpperCAmelCase_  ) * equation(UpperCAmelCase_  ) < 0:
      __UpperCAmelCase    :						Union[str, Any]       =						c
    else:
      __UpperCAmelCase    :						str       =						c
  return c


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  print(bisection(-2, 5))
  print(bisection(0, 6))