





from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFRoFormerForCausalLM,
          TFRoFormerForMaskedLM,
          TFRoFormerForMultipleChoice,
          TFRoFormerForQuestionAnswering,
          TFRoFormerForSequenceClassification,
          TFRoFormerForTokenClassification,
          TFRoFormerModel,
      )
      from transformers.models.roformer.modeling_tf_roformer import (
          TFRoFormerSelfAttention,
          TFRoFormerSinusoidalPositionalEmbedding,
      )

class 		UpperCamelCase__			:



     '''simple docstring'''

     def __init__(							self						:   List[str]						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   Tuple=13						,lowerCamelCase__						:   List[Any]=7						,lowerCamelCase__						:   Optional[Any]=True						,lowerCamelCase__						:   Union[str, Any]=True						,lowerCamelCase__						:   str=True						,lowerCamelCase__						:   Optional[Any]=True						,lowerCamelCase__						:   Tuple=99						,lowerCamelCase__						:   List[str]=32						,lowerCamelCase__						:   Tuple=2						,lowerCamelCase__						:   str=4						,lowerCamelCase__						:   Dict=37						,lowerCamelCase__						:   Optional[int]="gelu"						,lowerCamelCase__						:   Any=0.1						,lowerCamelCase__						:   List[str]=0.1						,lowerCamelCase__						:   int=512						,lowerCamelCase__						:   Any=16						,lowerCamelCase__						:   Any=2						,lowerCamelCase__						:   Any=0.02						,lowerCamelCase__						:   int=3						,lowerCamelCase__						:   int=4						,lowerCamelCase__						:   List[Any]=None						,)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						parent
           SCREAMING_SNAKE_CASE		=						13
           SCREAMING_SNAKE_CASE		=						7
           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						99
           SCREAMING_SNAKE_CASE		=						32
           SCREAMING_SNAKE_CASE		=						2
           SCREAMING_SNAKE_CASE		=						4
           SCREAMING_SNAKE_CASE		=						37
           SCREAMING_SNAKE_CASE		=						"""gelu"""
           SCREAMING_SNAKE_CASE		=						0.1
           SCREAMING_SNAKE_CASE		=						0.1
           SCREAMING_SNAKE_CASE		=						512
           SCREAMING_SNAKE_CASE		=						16
           SCREAMING_SNAKE_CASE		=						2
           SCREAMING_SNAKE_CASE		=						0.02
           SCREAMING_SNAKE_CASE		=						3
           SCREAMING_SNAKE_CASE		=						4
           SCREAMING_SNAKE_CASE		=						None






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						ids_tensor([self.batch_size, self.seq_length]						,self.vocab_size	)

           SCREAMING_SNAKE_CASE		=						None
           if self.use_input_mask:
                 SCREAMING_SNAKE_CASE		=						random_attention_mask([self.batch_size, self.seq_length]	)

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

           SCREAMING_SNAKE_CASE		=						None
           SCREAMING_SNAKE_CASE		=						None
           SCREAMING_SNAKE_CASE		=						None
           if self.use_labels:
                 SCREAMING_SNAKE_CASE		=						ids_tensor([self.batch_size]						,self.type_sequence_label_size	)
                 SCREAMING_SNAKE_CASE		=						ids_tensor([self.batch_size, self.seq_length]						,self.num_labels	)
                 SCREAMING_SNAKE_CASE		=						ids_tensor([self.batch_size]						,self.num_choices	)

           SCREAMING_SNAKE_CASE		=						RoFormerConfig(
               vocab_size=self.vocab_size						,hidden_size=self.hidden_size						,num_hidden_layers=self.num_hidden_layers						,num_attention_heads=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						,max_position_embeddings=self.max_position_embeddings						,type_vocab_size=self.type_vocab_size						,initializer_range=self.initializer_range						,return_dict=lowerCamelCase__						,)

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






     def     SCREAMING_SNAKE_CASE__  (							self						:   int						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   int						,lowerCamelCase__						:   Union[str, Any]						,lowerCamelCase__						:   Optional[Any]						,lowerCamelCase__						:   Optional[int]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   int	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerModel(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

           SCREAMING_SNAKE_CASE		=						[input_ids, input_mask]
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)

           self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict						,lowerCamelCase__						:   Optional[int]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   Dict						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   Tuple						,lowerCamelCase__						:   List[Any]	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						TFRoFormerForCausalLM(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)["""logits"""]
           self.parent.assertListEqual(
               list(prediction_scores.numpy().shape	)						,[self.batch_size, self.seq_length, self.vocab_size]	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   int						,lowerCamelCase__						:   Dict						,lowerCamelCase__						:   Tuple						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   List[str]	)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerForMaskedLM(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)
           self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.vocab_size)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Union[str, Any]						,lowerCamelCase__						:   Union[str, Any]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   Dict						,lowerCamelCase__						:   str						,lowerCamelCase__						:   str	)					->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.num_labels
           SCREAMING_SNAKE_CASE		=						TFRoFormerForSequenceClassification(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }

           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)
           self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.num_labels)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]						,lowerCamelCase__						:   Optional[Any]						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Union[str, Any]						,lowerCamelCase__						:   str						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   str						,lowerCamelCase__						:   List[str]	)					->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.num_choices
           SCREAMING_SNAKE_CASE		=						TFRoFormerForMultipleChoice(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						tf.tile(tf.expand_dims(lowerCamelCase__						,1	)						,(1, self.num_choices, 1)	)
           SCREAMING_SNAKE_CASE		=						tf.tile(tf.expand_dims(lowerCamelCase__						,1	)						,(1, self.num_choices, 1)	)
           SCREAMING_SNAKE_CASE		=						tf.tile(tf.expand_dims(lowerCamelCase__						,1	)						,(1, self.num_choices, 1)	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": multiple_choice_inputs_ids,
               """attention_mask""": multiple_choice_input_mask,
               """token_type_ids""": multiple_choice_token_type_ids,
           }
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)
           self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.num_choices)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Dict						,lowerCamelCase__						:   List[str]	)					->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.num_labels
           SCREAMING_SNAKE_CASE		=						TFRoFormerForTokenClassification(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)
           self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.num_labels)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]						,lowerCamelCase__						:   int						,lowerCamelCase__						:   Tuple						,lowerCamelCase__						:   str						,lowerCamelCase__						:   Optional[Any]						,lowerCamelCase__						:   Any						,lowerCamelCase__						:   Optional[Any]						,lowerCamelCase__						:   List[Any]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerForQuestionAnswering(config=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }

           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)
           self.parent.assertEqual(result.start_logits.shape						,(self.batch_size, self.seq_length)	)
           self.parent.assertEqual(result.end_logits.shape						,(self.batch_size, self.seq_length)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.prepare_config_and_inputs()
           (
               (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), (
               SCREAMING_SNAKE_CASE
           ), 
           )		=						config_and_inputs
           SCREAMING_SNAKE_CASE		=						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
           return config, inputs_dict

@require_tf
class 		UpperCamelCase__			(				lowerCAmelCase_							,				lowerCAmelCase_							,				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     Dict		     =      (
         (
             TFRoFormerModel,
             TFRoFormerForCausalLM,
             TFRoFormerForMaskedLM,
             TFRoFormerForQuestionAnswering,
             TFRoFormerForSequenceClassification,
             TFRoFormerForTokenClassification,
             TFRoFormerForMultipleChoice,
         )
         if is_tf_available()
         else ()
     )
     __snake_case   :     str		     =      (
         {
             "feature-extraction": TFRoFormerModel,
             "fill-mask": TFRoFormerForMaskedLM,
             "question-answering": TFRoFormerForQuestionAnswering,
             "text-classification": TFRoFormerForSequenceClassification,
             "text-generation": TFRoFormerForCausalLM,
             "token-classification": TFRoFormerForTokenClassification,
             "zero-shot": TFRoFormerForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )

     __snake_case   :     Optional[int]		     =      False
     __snake_case   :     str		     =      False






     def     SCREAMING_SNAKE_CASE__  (							self						:   str						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   Union[str, Any]						,lowerCamelCase__						:   str	)					->		int:




           '''simple docstring'''


           if pipeline_test_casse_name == "TextGenerationPipelineTests":
                 return True

           return False






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerModelTester(self	)
           SCREAMING_SNAKE_CASE		=						ConfigTester(self						,config_class=lowerCamelCase__						,hidden_size=37	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		str:




           '''simple docstring'''


           self.config_tester.run_common_tests()






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_lm_head(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__	)






     @slow
     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base"""	)
           self.assertIsNotNone(lowerCamelCase__	)

@require_tf
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     @slow
     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base"""	)
           SCREAMING_SNAKE_CASE		=						tf.constant([[0, 1, 2, 3, 4, 5]]	)
           SCREAMING_SNAKE_CASE		=						model(lowerCamelCase__	)[0]

           # TODO Replace vocab size
           SCREAMING_SNAKE_CASE		=						50000

           SCREAMING_SNAKE_CASE		=						[1, 6, vocab_size]
           self.assertEqual(output.shape						,lowerCamelCase__	)

           print(output[:, :3, :3]	)

           # TODO Replace values below with what was printed above.
           SCREAMING_SNAKE_CASE		=						tf.constant(
               [
                   [
                       [-0.12053341, -1.0264901, 0.29221946],
                       [-1.5133783, 0.197433, 0.15190607],
                       [-5.0135403, -3.900256, -0.84038764],
                   ]
               ]	)
           tf.debugging.assert_near(output[:, :3, :3]						,lowerCamelCase__						,atol=1e-4	)

@require_tf
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     str		     =      1E-4






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tf.constant([[4, 10]]	)
           SCREAMING_SNAKE_CASE		=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=6						,embedding_dim=6	)

           SCREAMING_SNAKE_CASE		=						emba(input_ids.shape	)
           SCREAMING_SNAKE_CASE		=						tf.constant(
               [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]	)

           tf.debugging.assert_near(lowerCamelCase__						,lowerCamelCase__						,atol=self.tolerance	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tf.constant(
               [
                   [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
                   [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
                   [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
               ]	)
           SCREAMING_SNAKE_CASE		=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=512						,embedding_dim=512	)
           emba([2, 16, 512]	)
           SCREAMING_SNAKE_CASE		=						emba.weight[:3, :5]

           tf.debugging.assert_near(lowerCamelCase__						,lowerCamelCase__						,atol=self.tolerance	)

@require_tf
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     str		     =      1E-4






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tf.reshape(tf.range(2 * 12 * 16 * 64						,dtype=tf.floataa	)						,shape=(2, 12, 16, 64)	) / 100

           SCREAMING_SNAKE_CASE		=						-tf.reshape(tf.range(2 * 12 * 16 * 64						,dtype=tf.floataa	)						,shape=(2, 12, 16, 64)	) / 100

           SCREAMING_SNAKE_CASE		=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=32						,embedding_dim=64	)
           SCREAMING_SNAKE_CASE		=						embed_positions([2, 16, 768]	)[None, None, :, :]

           SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE		=						TFRoFormerSelfAttention.apply_rotary_position_embeddings(
               lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						tf.constant(
               [
                   [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
                   [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
                   [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
                   [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
                   [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
                   [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
               ]	)
           SCREAMING_SNAKE_CASE		=						tf.constant(
               [
                   [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
                   [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
                   [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
                   [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
                   [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
                   [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
               ]	)

           tf.debugging.assert_near(query_layer[0, 0, :6, :8]						,lowerCamelCase__						,atol=self.tolerance	)
           tf.debugging.assert_near(key_layer[0, 0, :6, :8]						,lowerCamelCase__						,atol=self.tolerance	)









def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       int:


      '''simple docstring'''


      if index == number_of_items:
            return 0
      SCREAMING_SNAKE_CASE		=						0
      SCREAMING_SNAKE_CASE		=						0
      SCREAMING_SNAKE_CASE		=						knapsack(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						index + 1     )
      if weights[index] <= max_weight:
            SCREAMING_SNAKE_CASE		=						values[index] + knapsack(
                _SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						max_weight - weights[index]			,						index + 1     )
      return max(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )


if __name__ == "__main__":
      import doctest

      doctest.testmod()


