



'''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     UpperCAmelCase_       (       unittest.TestCase	):
    """simple docstring"""







    lowercase					=		MODEL_FOR_MASKED_LM_MAPPING
    lowercase					=		TF_MODEL_FOR_MASKED_LM_MAPPING




    def lowerCamelCase       (    self					:     List[str]						):
          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					:     List[str]						):
          snake_case__  :    Tuple    						=      pipeline(task="""fill-mask""" ,     model="""sshleifer/tiny-distilroberta-base""" ,     top_k=2 ,     framework="""tf"""						)
          snake_case__  :    str    						=      unmasker("""My name is <mask>"""						)
          self.assertEqual(
              nested_simplify(__snake_case ,     decimals=6						) ,     [
                  {"""sequence""": """My name is grouped""", """score""": 2.1E-0_5, """token""": 38_015, """token_str""": """ grouped"""},
                  {"""sequence""": """My name is accuser""", """score""": 2.1E-0_5, """token""": 25_506, """token_str""": """ accuser"""},
              ] ,     )

          snake_case__  :    Optional[Any]    						=      unmasker("""The largest city in France is <mask>"""						)
          self.assertEqual(
              nested_simplify(__snake_case ,     decimals=6						) ,     [
                  {
                      """sequence""": """The largest city in France is grouped""",
                      """score""": 2.1E-0_5,
                      """token""": 38_015,
                      """token_str""": """ grouped""",
                  },
                  {
                      """sequence""": """The largest city in France is accuser""",
                      """score""": 2.1E-0_5,
                      """token""": 25_506,
                      """token_str""": """ accuser""",
                  },
              ] ,     )

          snake_case__  :    Any    						=      unmasker("""My name is <mask>""" ,     targets=[""" Patrick""", """ Clara""", """ Teven"""] ,     top_k=3						)
          self.assertEqual(
              nested_simplify(__snake_case ,     decimals=6						) ,     [
                  {"""sequence""": """My name is Clara""", """score""": 2E-0_5, """token""": 13_606, """token_str""": """ Clara"""},
                  {"""sequence""": """My name is Patrick""", """score""": 2E-0_5, """token""": 3_499, """token_str""": """ Patrick"""},
                  {"""sequence""": """My name is Te""", """score""": 1.9E-0_5, """token""": 2_941, """token_str""": """ Te"""},
              ] ,     )




    @require_torch
    def lowerCamelCase       (    self					:     Optional[Any]						):
          snake_case__  :    Union[str, Any]    						=      pipeline(task="""fill-mask""" ,     model="""sshleifer/tiny-distilroberta-base""" ,     top_k=2 ,     framework="""pt"""						)

          snake_case__  :    List[Any]    						=      unmasker("""My name is <mask>"""						)
          self.assertEqual(
              nested_simplify(__snake_case ,     decimals=6						) ,     [
                  {"""sequence""": """My name is Maul""", """score""": 2.2E-0_5, """token""": 35_676, """token_str""": """ Maul"""},
                  {"""sequence""": """My name isELS""", """score""": 2.2E-0_5, """token""": 16_416, """token_str""": """ELS"""},
              ] ,     )

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

          snake_case__  :    Tuple    						=      unmasker("""My name is <mask>""" ,     targets=[""" Patrick""", """ Clara""", """ Teven"""] ,     top_k=3						)
          self.assertEqual(
              nested_simplify(__snake_case ,     decimals=6						) ,     [
                  {"""sequence""": """My name is Patrick""", """score""": 2.1E-0_5, """token""": 3_499, """token_str""": """ Patrick"""},
                  {"""sequence""": """My name is Te""", """score""": 2E-0_5, """token""": 2_941, """token_str""": """ Te"""},
                  {"""sequence""": """My name is Clara""", """score""": 2E-0_5, """token""": 13_606, """token_str""": """ Clara"""},
              ] ,     )

          snake_case__  :    int    						=      unmasker("""My name is <mask> <mask>""" ,     top_k=2						)

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




    @require_torch_gpu
    def lowerCamelCase       (    self					:     Optional[Any]						):
          snake_case__  :    List[Any]    						=      pipeline("""fill-mask""" ,     model="""hf-internal-testing/tiny-random-distilbert""" ,     device=0 ,     framework="""pt"""						)

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

          snake_case__  :    List[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(__snake_case ,     __snake_case						)




    @slow
    @require_torch
    def lowerCamelCase       (    self					:     Optional[Any]						):
          snake_case__  :    Tuple    						=      pipeline(task="""fill-mask""" ,     model="""distilroberta-base""" ,     top_k=2 ,     framework="""pt"""						)
          self.run_large_test(__snake_case						)




    @slow
    @require_tf
    def lowerCamelCase       (    self					:     Dict						):
          snake_case__  :    Tuple    						=      pipeline(task="""fill-mask""" ,     model="""distilroberta-base""" ,     top_k=2 ,     framework="""tf"""						)
          self.run_large_test(__snake_case						)




    def lowerCamelCase       (    self					:     Dict ,     snake_case_					:     Any						):
          snake_case__  :    List[str]    						=      unmasker("""My name is <mask>"""						)
          self.assertEqual(
              nested_simplify(__snake_case						) ,     [
                  {"""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"""},
              ] ,     )
          snake_case__  :    Optional[int]    						=      unmasker("""The largest city in France is <mask>"""						)
          self.assertEqual(
              nested_simplify(__snake_case						) ,     [
                  {
                      """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""",
                  },
              ] ,     )

          snake_case__  :    Tuple    						=      unmasker("""My name is <mask>""" ,     targets=[""" Patrick""", """ Clara""", """ Teven"""] ,     top_k=3						)
          self.assertEqual(
              nested_simplify(__snake_case						) ,     [
                  {"""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					:     Union[str, Any]						):
          snake_case__  :    List[str]    						=      pipeline(task="""fill-mask""" ,     model="""sshleifer/tiny-distilroberta-base""" ,     framework="""pt"""						)
          snake_case__  :    Optional[Any]    						=      None
          snake_case__  :    Union[str, Any]    						=      None
          self.run_pipeline_test(__snake_case ,     []						)




    @require_tf
    def lowerCamelCase       (    self					:     Dict						):
          snake_case__  :    List[str]    						=      pipeline(task="""fill-mask""" ,     model="""sshleifer/tiny-distilroberta-base""" ,     framework="""tf"""						)
          snake_case__  :    Dict    						=      None
          snake_case__  :    Union[str, Any]    						=      None
          self.run_pipeline_test(__snake_case ,     []						)




    def lowerCamelCase       (    self					:     Union[str, Any] ,     snake_case_					:     Optional[int] ,     snake_case_					:     int ,     snake_case_					:     Optional[int]						):
          if tokenizer is None or tokenizer.mask_token_id is None:
                self.skipTest("""The provided tokenizer has no mask token, (probably reformer or wav2vec2)"""						)

          snake_case__  :    Union[str, Any]    						=      FillMaskPipeline(model=__snake_case ,     tokenizer=__snake_case						)
          snake_case__  :    Optional[Any]    						=      [
              f"This is another {tokenizer.mask_token} test",
          ]
          return fill_masker, examples




    def lowerCamelCase       (    self					:     List[str] ,     snake_case_					:     Any ,     snake_case_					:     str						):
          snake_case__  :    int    						=      fill_masker.tokenizer
          snake_case__  :    Tuple    						=      fill_masker.model

          snake_case__  :    Optional[Any]    						=      fill_masker(
              f"This is a {tokenizer.mask_token}" ,     )
          self.assertEqual(
              __snake_case ,     [
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
              ] ,     )

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

          snake_case__  :    Union[str, Any]    						=      fill_masker([f"This is a {tokenizer.mask_token}", f"Another {tokenizer.mask_token} great test."]						)
          self.assertEqual(
              __snake_case ,     [
                  [
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  ],
                  [
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  ],
              ] ,     )

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

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




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

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

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

          # Raises with invalid
          with self.assertRaises(__snake_case						):
                snake_case__  :    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(__snake_case						):
                      snake_case__  :    Union[str, Any]    						=      fill_masker(f"This is a {tokenizer.mask_token}" ,     targets=[""""""]						)
                with self.assertRaises(__snake_case						):
                      snake_case__  :    Any    						=      fill_masker(f"This is a {tokenizer.mask_token}" ,     targets=""""""						)




    def lowerCamelCase       (    self					:     Optional[Any] ,     snake_case_					:     Any ,     snake_case_					:     Optional[int]						):
          snake_case__  :    List[Any]    						=      FillMaskPipeline(model=__snake_case ,     tokenizer=__snake_case ,     top_k=2						)
          snake_case__  :    Optional[int]    						=      fill_masker(f"This is a {tokenizer.mask_token}"						)
          self.assertEqual(
              __snake_case ,     [
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
              ] ,     )

          snake_case__  :    Union[str, Any]    						=      FillMaskPipeline(model=__snake_case ,     tokenizer=__snake_case						)
          snake_case__  :    Tuple    						=      fill_masker(f"This is a {tokenizer.mask_token}" ,     top_k=2						)
          self.assertEqual(
              __snake_case ,     [
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
              ] ,     )
          self.assertEqual(nested_simplify(__snake_case						) ,     nested_simplify(__snake_case						)						)




    def lowerCamelCase       (    self					:     Dict ,     snake_case_					:     List[Any] ,     snake_case_					:     Tuple						):
          snake_case__  :    List[str]    						=      tokenizer.get_vocab()
          snake_case__  :    Optional[int]    						=      FillMaskPipeline(model=__snake_case ,     tokenizer=__snake_case						)

          # top_k=2, ntargets=3
          snake_case__  :    Union[str, Any]    						=      sorted(vocab.keys()						)[:3]
          snake_case__  :    Any    						=      fill_masker(f"This is a {tokenizer.mask_token}" ,     top_k=2 ,     targets=__snake_case						)

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




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

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




    def lowerCamelCase       (    self					:     Tuple ,     snake_case_					:     Optional[Any] ,     snake_case_					:     Union[str, Any]						):
          snake_case__  :    List[Any]    						=      FillMaskPipeline(model=__snake_case ,     tokenizer=__snake_case						)

          snake_case__  :    Optional[Any]    						=      fill_masker(
              f"This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}" ,     top_k=2						)
          self.assertEqual(
              __snake_case ,     [
                  [
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  ],
                  [
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  ],
                  [
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                      {"""sequence""": ANY(__snake_case						), """score""": ANY(__snake_case						), """token""": ANY(__snake_case						), """token_str""": ANY(__snake_case						)},
                  ],
              ] ,     )





'''simple docstring'''






from __future__ import annotations


def  snake_case_     (					_lowerCAmelCase  :						list[int | float]   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int  )      ->   int | float:
							if len(_lowerCAmelCase  ) == 0:
														raise ValueError('''find_max() arg is an empty sequence'''  )
							if (
							    left >= len(_lowerCAmelCase  )
							    or left < -len(_lowerCAmelCase  )
							    or right >= len(_lowerCAmelCase  )
							    or right < -len(_lowerCAmelCase  )
							):
														raise IndexError('''list index out of range'''  )
							if left == right:
														return nums[left]
							UpperCAmelCase :       List[Any] 							=		(left + right) >> 1  # the middle
							UpperCAmelCase :       Optional[Any] 							=		find_max(_lowerCAmelCase   ,      _lowerCAmelCase   ,      _lowerCAmelCase  )  # find max in range[left, mid]
							UpperCAmelCase :       Dict 							=		find_max(_lowerCAmelCase   ,      mid + 1   ,      _lowerCAmelCase  )  # find max in range[mid + 1, right]

							return left_max if left_max >= right_max else right_max


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)





