

"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers.models.gptj.modeling_tf_gptj import (
          TFGPTJForCausalLM,
          TFGPTJForQuestionAnswering,
          TFGPTJForSequenceClassification,
          TFGPTJModel,
          shape_list,
      )






class       _UpperCAmelCase     :
   def __init__(						self ,						_A       )      ->      Optional[int]:






    '''simple docstring'''







    _UpperCAmelCase      :							Any       =   parent
    _UpperCAmelCase      :							str       =   13
    _UpperCAmelCase      :							Tuple       =   7
    _UpperCAmelCase      :							Any       =   True
    _UpperCAmelCase      :							List[str]       =   True
    _UpperCAmelCase      :							str       =   True
    _UpperCAmelCase      :							Tuple       =   True
    _UpperCAmelCase      :							Optional[Any]       =   True
    _UpperCAmelCase      :							Any       =   99
    _UpperCAmelCase      :							Any       =   32
    _UpperCAmelCase      :							List[str]       =   4
    _UpperCAmelCase      :							Dict       =   2
    _UpperCAmelCase      :							List[str]       =   4
    _UpperCAmelCase      :							int       =   37
    _UpperCAmelCase      :							str       =   "gelu"
    _UpperCAmelCase      :							int       =   0.1
    _UpperCAmelCase      :							Tuple       =   0.1
    _UpperCAmelCase      :							Optional[int]       =   5_12
    _UpperCAmelCase      :							Any       =   16
    _UpperCAmelCase      :							Dict       =   2
    _UpperCAmelCase      :							str       =   0.02
    _UpperCAmelCase      :							Any       =   3
    _UpperCAmelCase      :							List[str]       =   4
    _UpperCAmelCase      :							int       =   None
    _UpperCAmelCase      :							Union[str, Any]       =   self.vocab_size - 1
    _UpperCAmelCase      :							List[str]       =   self.vocab_size - 1
    _UpperCAmelCase      :							Optional[int]       =   self.vocab_size - 1
   def 							__snake_case	(						self       )      ->      Dict:






    '''simple docstring'''







    _UpperCAmelCase      :							Optional[Any]       =   ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size       )

    _UpperCAmelCase      :							List[str]       =   None
    if self.use_input_mask:
     _UpperCAmelCase      :							List[Any]       =   random_attention_mask([self.batch_size, self.seq_length]       )

    _UpperCAmelCase      :							List[Any]       =   None
    if self.use_token_type_ids:
     _UpperCAmelCase      :							Any       =   ids_tensor([self.batch_size, self.seq_length] ,						self.type_vocab_size       )

    _UpperCAmelCase      :							Any       =   None
    if self.use_mc_token_ids:
     _UpperCAmelCase      :							List[str]       =   ids_tensor([self.batch_size, self.num_choices] ,						self.seq_length       )

    _UpperCAmelCase      :							str       =   None
    _UpperCAmelCase      :							Optional[Any]       =   None
    _UpperCAmelCase      :							Union[str, Any]       =   None
    if self.use_labels:
     _UpperCAmelCase      :							str       =   ids_tensor([self.batch_size] ,						self.type_sequence_label_size       )
     _UpperCAmelCase      :							Dict       =   ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels       )
     _UpperCAmelCase      :							List[Any]       =   ids_tensor([self.batch_size] ,						self.num_choices       )

    _UpperCAmelCase      :							Any       =   GPTJConfig(
        vocab_size=self.vocab_size ,						n_embd=self.hidden_size ,						n_layer=self.num_hidden_layers ,						n_head=self.num_attention_heads ,						intermediate_size=self.intermediate_size ,						hidden_act=self.hidden_act ,						hidden_dropout_prob=self.hidden_dropout_prob ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob ,						n_positions=self.max_position_embeddings ,						type_vocab_size=self.type_vocab_size ,						initializer_range=self.initializer_range ,						bos_token_id=self.bos_token_id ,						eos_token_id=self.eos_token_id ,						pad_token_id=self.pad_token_id ,						rotary_dim=self.rotary_dim ,						return_dict=_A ,						)

    _UpperCAmelCase      :							Any       =   ids_tensor([self.num_hidden_layers, self.num_attention_heads] ,						2       )

    return (
        config,
        input_ids,
        input_mask,
        head_mask,
        token_type_ids,
        mc_token_ids,
        sequence_labels,
        token_labels,
        choice_labels,
    )
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A ,						*_A       )      ->      Optional[Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							Optional[int]       =   TFGPTJModel(config=_A       )
    _UpperCAmelCase      :							Optional[int]       =   {
        "input_ids": input_ids,
        "attention_mask": input_mask,
        "token_type_ids": token_type_ids,
    }
    _UpperCAmelCase      :							Any       =   model(_A       )

    _UpperCAmelCase      :							Any       =   [input_ids, None, input_mask]  # None is the input for 'past'
    _UpperCAmelCase      :							str       =   model(_A       )

    _UpperCAmelCase      :							int       =   model(_A       )

    self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)       )
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A ,						*_A       )      ->      Dict:






    '''simple docstring'''







    _UpperCAmelCase      :							Dict       =   TFGPTJModel(config=_A       )

    # first forward pass
    _UpperCAmelCase      :							Tuple       =   model(_A ,						token_type_ids=_A ,						use_cache=_A       )
    _UpperCAmelCase      :							int       =   model(_A ,						token_type_ids=_A       )
    _UpperCAmelCase      :							List[str]       =   model(_A ,						token_type_ids=_A ,						use_cache=_A       )

    self.parent.assertTrue(len(_A       ) == len(_A       )       )
    self.parent.assertTrue(len(_A       ) == len(_A       ) + 1       )

    _UpperCAmelCase      :							int       =   outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    _UpperCAmelCase      :							Dict       =   ids_tensor((self.batch_size, 1) ,						config.vocab_size       )
    _UpperCAmelCase      :							Optional[int]       =   ids_tensor([self.batch_size, 1] ,						self.type_vocab_size       )

    # append to next input_ids and token_type_ids
    _UpperCAmelCase      :							List[Any]       =   tf.concat([input_ids, next_tokens] ,						axis=-1       )
    _UpperCAmelCase      :							Union[str, Any]       =   tf.concat([token_type_ids, next_token_types] ,						axis=-1       )

    _UpperCAmelCase      :							int       =   model(_A ,						token_type_ids=_A       )["last_hidden_state"]
    _UpperCAmelCase      :							Dict       =   model(_A ,						token_type_ids=_A ,						past_key_values=_A       )[
        "last_hidden_state"
    ]

    # select random slice
    _UpperCAmelCase      :							Union[str, Any]       =   int(ids_tensor((1,) ,						shape_list(_A       )[-1]       )       )
    _UpperCAmelCase      :							Union[str, Any]       =   output_from_no_past[:, -1, random_slice_idx]
    _UpperCAmelCase      :							Optional[int]       =   output_from_past[:, 0, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(_A ,						_A ,						rtol=1e-6       )
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A ,						*_A       )      ->      List[str]:






    '''simple docstring'''







    _UpperCAmelCase      :							Tuple       =   TFGPTJModel(config=_A       )

    # create attention mask
    _UpperCAmelCase      :							Optional[Any]       =   self.seq_length // 2
    _UpperCAmelCase      :							Optional[Any]       =   tf.ones((self.batch_size, half_seq_length) ,						dtype=tf.intaa       )
    _UpperCAmelCase      :							Any       =   tf.zeros((self.batch_size, self.seq_length - half_seq_length) ,						dtype=tf.intaa       )
    _UpperCAmelCase      :							str       =   tf.concat([attn_mask_begin, attn_mask_end] ,						axis=1       )

    # first forward pass
    _UpperCAmelCase      :							Optional[int]       =   model(_A ,						attention_mask=_A       ).to_tuple()

    # create hypothetical next token and extent to next_input_ids
    _UpperCAmelCase      :							Union[str, Any]       =   ids_tensor((self.batch_size, 1) ,						config.vocab_size       )

    # change a random masked slice from input_ids
    _UpperCAmelCase      :							Optional[int]       =   ids_tensor((1,) ,						_A       ).numpy() + 1
    _UpperCAmelCase      :							List[str]       =   ids_tensor((self.batch_size, self.seq_length) ,						config.vocab_size       )
    _UpperCAmelCase      :							Tuple       =   tf.range(self.seq_length       ) == (self.seq_length - random_seq_idx_to_change)
    _UpperCAmelCase      :							List[Any]       =   tf.transpose(
        tf.broadcast_to(tf.expand_dims(_A ,						-1       ) ,						(self.seq_length, self.batch_size)       )       )
    _UpperCAmelCase      :							Optional[int]       =   tf.where(_A ,						_A ,						_A       )

    # append to next input_ids and attn_mask
    _UpperCAmelCase      :							Optional[Any]       =   tf.concat([input_ids, next_tokens] ,						axis=-1       )
    _UpperCAmelCase      :							Optional[int]       =   tf.concat([attn_mask, tf.ones((shape_list(_A       )[0], 1) ,						dtype=tf.intaa       )] ,						axis=1       )

    # get two different outputs
    _UpperCAmelCase      :							List[Any]       =   model(_A ,						attention_mask=_A       )["last_hidden_state"]
    _UpperCAmelCase      :							Union[str, Any]       =   model(_A ,						past_key_values=_A ,						attention_mask=_A       )[
        "last_hidden_state"
    ]

    # select random slice
    _UpperCAmelCase      :							Optional[Any]       =   int(ids_tensor((1,) ,						shape_list(_A       )[-1]       )       )
    _UpperCAmelCase      :							Dict       =   output_from_no_past[:, -1, random_slice_idx]
    _UpperCAmelCase      :							str       =   output_from_past[:, 0, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(_A ,						_A ,						rtol=1e-12       )
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A ,						*_A       )      ->      str:






    '''simple docstring'''







    _UpperCAmelCase      :							Dict       =   TFGPTJModel(config=_A       )

    _UpperCAmelCase      :							Optional[int]       =   input_ids[:1, :]
    _UpperCAmelCase      :							Dict       =   input_mask[:1, :]
    _UpperCAmelCase      :							Tuple       =   token_type_ids[:1, :]
    _UpperCAmelCase      :							Optional[Any]       =   1

    # first forward pass
    _UpperCAmelCase      :							Tuple       =   model(_A ,						attention_mask=_A ,						token_type_ids=_A ,						use_cache=_A       )

    _UpperCAmelCase      :							Any       =   outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    _UpperCAmelCase      :							List[str]       =   ids_tensor((self.batch_size, 3) ,						config.vocab_size       )
    _UpperCAmelCase      :							Tuple       =   ids_tensor((self.batch_size, 3) ,						2       )
    _UpperCAmelCase      :							int       =   ids_tensor((self.batch_size, 3) ,						self.type_vocab_size       )

    # append to next input_ids and token_type_ids
    _UpperCAmelCase      :							Dict       =   tf.concat([input_ids, next_tokens] ,						axis=-1       )
    _UpperCAmelCase      :							Optional[Any]       =   tf.concat([input_mask, next_attn_mask] ,						axis=-1       )
    _UpperCAmelCase      :							List[str]       =   tf.concat([token_type_ids, next_token_types] ,						axis=-1       )

    _UpperCAmelCase      :							int       =   model(
        _A ,						token_type_ids=_A ,						attention_mask=_A       )["last_hidden_state"]
    _UpperCAmelCase      :							Dict       =   model(
        _A ,						token_type_ids=_A ,						attention_mask=_A ,						past_key_values=_A ,						)["last_hidden_state"]
    self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]       )

    # select random slice
    _UpperCAmelCase      :							Tuple       =   int(ids_tensor((1,) ,						shape_list(_A       )[-1]       )       )
    _UpperCAmelCase      :							int       =   output_from_no_past[:, -3:, random_slice_idx]
    _UpperCAmelCase      :							Optional[Any]       =   output_from_past[:, :, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(_A ,						_A ,						rtol=1e-3       )
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A ,						*_A       )      ->      Dict:






    '''simple docstring'''







    _UpperCAmelCase      :							Tuple       =   TFGPTJForCausalLM(config=_A       )
    _UpperCAmelCase      :							Optional[int]       =   {
        "input_ids": input_ids,
        "attention_mask": input_mask,
        "token_type_ids": token_type_ids,
    }
    _UpperCAmelCase      :							List[str]       =   model(_A       )
    self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size)       )
   def 							__snake_case	(						self       )      ->      Tuple:






    '''simple docstring'''







    _UpperCAmelCase      :							List[Any]       =   self.prepare_config_and_inputs()

    (
        _UpperCAmelCase			
    )      :							int       =   config_and_inputs

    _UpperCAmelCase      :							Union[str, Any]       =   {
        "input_ids": input_ids,
        "token_type_ids": token_type_ids,
        "attention_mask": input_mask,
    }
    return config, inputs_dict






@require_tf
class       _UpperCAmelCase     (						lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       unittest.TestCase):
   __a	:    Dict			   =							(
       (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
       if is_tf_available()
       else ()
   )

   __a	:    Union[str, Any]			   =							(TFGPTJForCausalLM,) if is_tf_available() else ()
   __a	:    str			   =							(
       {
           """feature-extraction""": TFGPTJModel,
           """question-answering""": TFGPTJForQuestionAnswering,
           """text-classification""": TFGPTJForSequenceClassification,
           """text-generation""": TFGPTJForCausalLM,
           """zero-shot""": TFGPTJForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __a	:    List[Any]			   =							False
   __a	:    Any			   =							False
   __a	:    List[str]			   =							False
   __a	:    Dict			   =							False
   def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A ,						_A       )      ->      List[str]:






    '''simple docstring'''







    if (
        pipeline_test_casse_name == "QAPipelineTests"
        and tokenizer_name is not None
        and not tokenizer_name.endswith("""Fast"""       )
    ):
     # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
     # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
     # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
     return True

    return False
   def 							__snake_case	(						self       )      ->      List[Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							List[Any]       =   TFGPTJModelTester(self       )
    _UpperCAmelCase      :							Dict       =   ConfigTester(self ,						config_class=_A ,						n_embd=37       )
   def 							__snake_case	(						self       )      ->      str:






    '''simple docstring'''







    self.config_tester.run_common_tests()
   def 							__snake_case	(						self       )      ->      Dict:






    '''simple docstring'''







    _UpperCAmelCase      :							List[Any]       =   self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model(*_A       )
   def 							__snake_case	(						self       )      ->      Optional[Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							List[Any]       =   self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_past(*_A       )
   def 							__snake_case	(						self       )      ->      Union[str, Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							Optional[Any]       =   self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_attention_mask_past(*_A       )
   def 							__snake_case	(						self       )      ->      Union[str, Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							Dict       =   self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_past_large_inputs(*_A       )
   def 							__snake_case	(						self       )      ->      Any:






    '''simple docstring'''







    _UpperCAmelCase      :							Any       =   self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_lm_head_model(*_A       )
   @slow
   @unittest.skipIf(
       not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""       )       ) > 0 ,						"""skip testing on GPU for now to avoid GPU OOM.""" ,						)
   def 							__snake_case	(						self       )      ->      Optional[Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							Dict       =   TFGPTJModel.from_pretrained("""EleutherAI/gpt-j-6B""" ,						from_pt=_A       )
    self.assertIsNotNone(_A       )
   @unittest.skip(reason="""Currently, model embeddings are going to undergo a major refactor."""       )
   def 							__snake_case	(						self       )      ->      Tuple:






    '''simple docstring'''







    super().test_resize_token_embeddings()






@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class       _UpperCAmelCase     (						unittest.TestCase):
   def 							__snake_case	(						self       )      ->      Optional[int]:






    '''simple docstring'''







    _UpperCAmelCase      :							Tuple       =   TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B""" ,						from_pt=_A       )
    _UpperCAmelCase      :							Optional[Any]       =   tf.convert_to_tensor([[4_64, 32_90]] ,						dtype=tf.intaa       )  # The dog
    # fmt: off
    # The dog is a man's best friend. It is a loyal companion, and it is a friend
    _UpperCAmelCase      :							List[Any]       =   [4_64, 32_90, 3_18, 2_57, 5_82, 3_38, 12_66, 15_45, 13, 6_32, 3_18, 2_57, 91_12, 1_51_85, 11, 2_90, 3_40, 3_18, 2_57, 15_45]
    # fmt: on
    _UpperCAmelCase      :							int       =   model.generate(_A ,						do_sample=_A       )
    self.assertListEqual(output_ids[0].numpy().tolist() ,						_A       )
   def 							__snake_case	(						self       )      ->      Tuple:






    '''simple docstring'''







    _UpperCAmelCase      :							Optional[Any]       =   AutoTokenizer.from_pretrained("""EleutherAI/gpt-j-6B""" ,						revision="""float16"""       )
    _UpperCAmelCase      :							List[str]       =   TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B""" ,						revision="""float16""" ,						from_pt=_A       )

    _UpperCAmelCase      :							int       =   tokenizer("""Today is a nice day and""" ,						return_tensors="""tf"""       )
    # forces the generation to happen on CPU, to avoid GPU-related quirks
    with tf.device(""":/CPU:0"""       ):
     _UpperCAmelCase      :							Union[str, Any]       =   model.generate(**_A ,						do_sample=_A ,						seed=[42, 0]       )
    _UpperCAmelCase      :							Tuple       =   tokenizer.decode(output_ids[0] ,						skip_special_tokens=_A       )

    _UpperCAmelCase      :							Dict       =   "Today is a nice day and I’m going to go for a walk. I’"
    self.assertEqual(_A ,						_A       )
   def 							__snake_case	(						self       )      ->      Union[str, Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							List[Any]       =   TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B""" ,						revision="""float16""" ,						from_pt=_A       )
    _UpperCAmelCase      :							str       =   AutoTokenizer.from_pretrained("""EleutherAI/gpt-j-6B""" ,						revision="""float16"""       )

    _UpperCAmelCase      :							List[str]       =   "left"

    # Define PAD Token = EOS Token = 50256
    _UpperCAmelCase      :							Any       =   tokenizer.eos_token
    _UpperCAmelCase      :							List[str]       =   model.config.eos_token_id

    # use different length sentences to test batching
    _UpperCAmelCase      :							int       =   [
        "Hello, my dog is a little",
        "Today, I",
    ]
    _UpperCAmelCase      :							Any       =   [
        "Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia",
        "Today, I’m going to be talking about a topic that’",
    ]
    return model, tokenizer, sentences, expected_output_sentences
   def 							__snake_case	(						self       )      ->      List[Any]:






    '''simple docstring'''







    _UpperCAmelCase      :							Optional[Any]       =   self._get_beam_search_test_objects()

    _UpperCAmelCase      :							int       =   tokenizer(_A ,						return_tensors="""tf""" ,						padding=_A       )
    _UpperCAmelCase      :							List[str]       =   model.generate(**_A ,						do_sample=_A ,						num_beams=2       )
    _UpperCAmelCase      :							Tuple       =   tokenizer.batch_decode(_A ,						skip_special_tokens=_A       )
    self.assertListEqual(_A ,						_A       )
   def 							__snake_case	(						self       )      ->      List[str]:






    '''simple docstring'''







    _UpperCAmelCase      :							Any       =   self._get_beam_search_test_objects()

    _UpperCAmelCase      :							int       =   tokenizer(_A ,						return_tensors="""tf""" ,						padding=_A       )
    _UpperCAmelCase      :							Any       =   tokenizer(sentences[0] ,						return_tensors="""tf"""       )
    _UpperCAmelCase      :							int       =   model.generate(**_A ,						do_sample=_A ,						num_beams=2       )
    _UpperCAmelCase      :							Union[str, Any]       =   (
        shape_list(inputs_non_padded["""input_ids"""]       )[-1]
        - tf.reduce_sum(tf.cast(inputs["""attention_mask"""][-1] ,						tf.intaa       )       ).numpy()
    )
    _UpperCAmelCase      :							Union[str, Any]       =   tokenizer(sentences[1] ,						return_tensors="""tf"""       )
    _UpperCAmelCase      :							Tuple       =   model.generate(
        **_A ,						do_sample=_A ,						num_beams=2 ,						max_length=model.config.max_length - num_paddings       )
    _UpperCAmelCase      :							int       =   tokenizer.decode(output_non_padded[0] ,						skip_special_tokens=_A       )
    _UpperCAmelCase      :							Union[str, Any]       =   tokenizer.decode(output_padded[0] ,						skip_special_tokens=_A       )
    self.assertListEqual(_A ,						[non_padded_sentence, padded_sentence]       )
   def 							__snake_case	(						self       )      ->      Dict:






    '''simple docstring'''







    _UpperCAmelCase      :							Any       =   self._get_beam_search_test_objects()

    _UpperCAmelCase      :							Tuple       =   tokenizer(_A ,						return_tensors="""tf""" ,						padding=_A       )
    _UpperCAmelCase      :							List[Any]       =   tf.function(model.generate ,						jit_compile=_A       )
    _UpperCAmelCase      :							Dict       =   xla_generate(**_A ,						do_sample=_A ,						num_beams=2       )
    _UpperCAmelCase      :							Optional[Any]       =   tokenizer.batch_decode(_A ,						skip_special_tokens=_A       )
    self.assertListEqual(_A ,						_A       )








"""simple docstring"""






import math
def  UpperCamelCase   (     _lowerCAmelCase       :  int	)			->     bool:

	if 1 < number < 4:
		# 2 and 3 are primes
		return True
	elif number < 2 or number % 2 == 0 or number % 3 == 0:
		# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
		return False

	# All primes number are in format of 6k +/- 1
	for i in range(5,					int(math.sqrt(_lowerCAmelCase	) + 1	),					6	):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True
def  UpperCamelCase   (     _lowerCAmelCase       :  int = 2000000	)			->     int:
	return sum(num for num in range(3,					_lowerCAmelCase,					2	) if is_prime(_lowerCAmelCase	)	) + 2 if n > 2 else 0


if __name__ == "__main__":
						print(F'''{solution() = }''')





