



"""simple docstring"""




import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
 import os

 # The slow tests are often failing with OOM error on GPU
 # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
 # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
 _lowerCAmelCase       :      str							=							"platform"

 import jax
 import jax.numpy as jnp

 from transformers import AutoTokenizer
 from transformers.models.mbart.modeling_flax_mbart import (
     FlaxMBartForConditionalGeneration,
     FlaxMBartForQuestionAnswering,
     FlaxMBartForSequenceClassification,
     FlaxMBartModel,
     shift_tokens_right,
 )

def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		List[Any]		,						SCREAMING_SNAKE_CASE__			:		Tuple		,						SCREAMING_SNAKE_CASE__			:		Optional[int]=None		,						SCREAMING_SNAKE_CASE__			:		str=None		,						SCREAMING_SNAKE_CASE__			:		List[Any]=None		,						SCREAMING_SNAKE_CASE__			:		Any=None		,						SCREAMING_SNAKE_CASE__			:		Any=None		,						SCREAMING_SNAKE_CASE__			:		Any=None		,						)						->     Optional[Any]:





     '''simple docstring'''

     if attention_mask is None:
          _UpperCAmelCase    :			Tuple              =					np.where(input_ids != config.pad_token_id		,						1		,						0       )
     if decoder_attention_mask is None:
          _UpperCAmelCase    :			int              =					np.where(decoder_input_ids != config.pad_token_id		,						1		,						0       )
     if head_mask is None:
          _UpperCAmelCase    :			Optional[int]              =					np.ones((config.encoder_layers, config.encoder_attention_heads)       )
     if decoder_head_mask is None:
          _UpperCAmelCase    :			int              =					np.ones((config.decoder_layers, config.decoder_attention_heads)       )
     if cross_attn_head_mask is None:
          _UpperCAmelCase    :			List[Any]              =					np.ones((config.decoder_layers, config.decoder_attention_heads)       )
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": decoder_attention_mask,
     }






class 			UpperCAmelCase_						(       unittest.TestCase		):



      def __init__(  self  :			int  ,			A  :			int  ,			A  :			Union[str, Any]=1_3  ,			A  :			List[Any]=7  ,			A  :			Any=True  ,			A  :			List[str]=False  ,			A  :			Any=9_9  ,			A  :			Union[str, Any]=1_6  ,			A  :			str=2  ,			A  :			Optional[int]=4  ,			A  :			Union[str, Any]=4  ,			A  :			List[str]="gelu"  ,			A  :			Dict=0.1  ,			A  :			Dict=0.1  ,			A  :			Union[str, Any]=3_2  ,			A  :			List[Any]=2  ,			A  :			List[Any]=1  ,			A  :			Any=0  ,			A  :			Dict=2  ,			A  :			int=0.02  ,			):
           _UpperCAmelCase    :			List[Any]              =					parent
           _UpperCAmelCase    :			Optional[int]              =					batch_size
           _UpperCAmelCase    :			str              =					seq_length
           _UpperCAmelCase    :			Optional[int]              =					is_training
           _UpperCAmelCase    :			Union[str, Any]              =					use_labels
           _UpperCAmelCase    :			Optional[Any]              =					vocab_size
           _UpperCAmelCase    :			List[str]              =					hidden_size
           _UpperCAmelCase    :			int              =					num_hidden_layers
           _UpperCAmelCase    :			Optional[int]              =					num_attention_heads
           _UpperCAmelCase    :			Optional[int]              =					intermediate_size
           _UpperCAmelCase    :			str              =					hidden_act
           _UpperCAmelCase    :			Optional[int]              =					hidden_dropout_prob
           _UpperCAmelCase    :			Dict              =					attention_probs_dropout_prob
           _UpperCAmelCase    :			Any              =					max_position_embeddings
           _UpperCAmelCase    :			int              =					eos_token_id
           _UpperCAmelCase    :			Tuple              =					pad_token_id
           _UpperCAmelCase    :			int              =					bos_token_id
           _UpperCAmelCase    :			Optional[int]              =					decoder_start_token_id
           _UpperCAmelCase    :			Union[str, Any]              =					initializer_range



      def 		snake_case_      (  self  :			List[str]		):
           _UpperCAmelCase    :			List[Any]              =					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]  ,			self.vocab_size		)  ,			3  ,			self.vocab_size		)
           _UpperCAmelCase    :			Union[str, Any]              =					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)  ,			dtype=np.intaa		))  ,			-1		)

           _UpperCAmelCase    :			str              =					shift_tokens_right(A  ,			1		)

           _UpperCAmelCase    :			List[str]              =					MBartConfig(
               vocab_size=self.vocab_size  ,			d_model=self.hidden_size  ,			encoder_layers=self.num_hidden_layers  ,			decoder_layers=self.num_hidden_layers  ,			encoder_attention_heads=self.num_attention_heads  ,			decoder_attention_heads=self.num_attention_heads  ,			encoder_ffn_dim=self.intermediate_size  ,			decoder_ffn_dim=self.intermediate_size  ,			dropout=self.hidden_dropout_prob  ,			attention_dropout=self.attention_probs_dropout_prob  ,			max_position_embeddings=self.max_position_embeddings  ,			eos_token_id=self.eos_token_id  ,			bos_token_id=self.bos_token_id  ,			pad_token_id=self.pad_token_id  ,			decoder_start_token_id=self.decoder_start_token_id  ,			initializer_range=self.initializer_range  ,			use_cache=A  ,			)
           _UpperCAmelCase    :			str              =					prepare_mbart_inputs_dict(A  ,			A  ,			A		)
           return config, inputs_dict



      def 		snake_case_      (  self  :			Dict		):
           _UpperCAmelCase       , _UpperCAmelCase    :			str              =					self.prepare_config_and_inputs()
           return config, inputs_dict



      def 		snake_case_      (  self  :			Optional[Any]  ,			A  :			str  ,			A  :			Dict  ,			A  :			Any		):
           _UpperCAmelCase    :			Any              =					2_0
           _UpperCAmelCase    :			List[str]              =					model_class_name(A		)

           _UpperCAmelCase    :			Any              =					model.encode(inputs_dict["input_ids"]		)

           _UpperCAmelCase       , _UpperCAmelCase    :			Union[str, Any]              =					(
               inputs_dict["decoder_input_ids"],
               inputs_dict["decoder_attention_mask"],
           )

           _UpperCAmelCase    :			int              =					model.init_cache(decoder_input_ids.shape[0]  ,			A  ,			A		)
           _UpperCAmelCase    :			Optional[int]              =					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)  ,			dtype="i4"		)

           _UpperCAmelCase    :			int              =					jnp.broadcast_to(
               jnp.arange(decoder_input_ids.shape[-1] - 1		)[None, :]  ,			(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)  ,			)
           _UpperCAmelCase    :			str              =					model.decode(
               decoder_input_ids[:, :-1]  ,			A  ,			decoder_attention_mask=A  ,			past_key_values=A  ,			decoder_position_ids=A  ,			)

           _UpperCAmelCase    :			List[str]              =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]  ,			dtype="i4"		)
           _UpperCAmelCase    :			List[Any]              =					model.decode(
               decoder_input_ids[:, -1:]  ,			A  ,			decoder_attention_mask=A  ,			past_key_values=outputs_cache.past_key_values  ,			decoder_position_ids=A  ,			)

           _UpperCAmelCase    :			Tuple              =					model.decode(A  ,			A		)

           _UpperCAmelCase    :			Optional[Any]              =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])		)		)
           self.parent.assertTrue(diff < 1e-3  ,			msg=f'Max diff is {diff}'		)



      def 		snake_case_      (  self  :			Dict  ,			A  :			Any  ,			A  :			List[Any]  ,			A  :			Dict		):
           _UpperCAmelCase    :			List[str]              =					2_0
           _UpperCAmelCase    :			List[str]              =					model_class_name(A		)

           _UpperCAmelCase    :			Tuple              =					model.encode(inputs_dict["input_ids"]		)

           _UpperCAmelCase       , _UpperCAmelCase    :			Any              =					(
               inputs_dict["decoder_input_ids"],
               inputs_dict["decoder_attention_mask"],
           )

           _UpperCAmelCase    :			List[Any]              =					jnp.concatenate(
               [
                   decoder_attention_mask,
                   jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])		),
               ]  ,			axis=-1  ,			)

           _UpperCAmelCase    :			Optional[Any]              =					model.init_cache(decoder_input_ids.shape[0]  ,			A  ,			A		)
           _UpperCAmelCase    :			Optional[Any]              =					jnp.broadcast_to(
               jnp.arange(decoder_input_ids.shape[-1] - 1		)[None, :]  ,			(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)  ,			)

           _UpperCAmelCase    :			Union[str, Any]              =					model.decode(
               decoder_input_ids[:, :-1]  ,			A  ,			decoder_attention_mask=A  ,			past_key_values=A  ,			decoder_position_ids=A  ,			)
           _UpperCAmelCase    :			Dict              =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]  ,			dtype="i4"		)
           _UpperCAmelCase    :			str              =					model.decode(
               decoder_input_ids[:, -1:]  ,			A  ,			past_key_values=outputs_cache.past_key_values  ,			decoder_attention_mask=A  ,			decoder_position_ids=A  ,			)

           _UpperCAmelCase    :			int              =					model.decode(A  ,			A  ,			decoder_attention_mask=A		)

           _UpperCAmelCase    :			str              =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])		)		)
           self.parent.assertTrue(diff < 1e-3  ,			msg=f'Max diff is {diff}'		)







@require_flax
class 			UpperCAmelCase_						(       unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:     str				  =				9_9



      def 		snake_case_      (  self  :			Optional[Any]		):
           _UpperCAmelCase    :			Optional[int]              =					np.array(
               [
                   [7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2],
                   [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2],
                   [5, 9_7, 1_7, 3_9, 9_4, 4_0, 2],
                   [7_6, 8_3, 9_4, 2_5, 7_0, 7_8, 2],
                   [8_7, 5_9, 4_1, 3_5, 4_8, 6_6, 2],
                   [5_5, 1_3, 1_6, 5_8, 5, 2, 1],  # note padding
                   [6_4, 2_7, 3_1, 5_1, 1_2, 7_5, 2],
                   [5_2, 6_4, 8_6, 1_7, 8_3, 3_9, 2],
                   [4_8, 6_1, 9, 2_4, 7_1, 8_2, 2],
                   [2_6, 1, 6_0, 4_8, 2_2, 1_3, 2],
                   [2_1, 5, 6_2, 2_8, 1_4, 7_6, 2],
                   [4_5, 9_8, 3_7, 8_6, 5_9, 4_8, 2],
                   [7_0, 7_0, 5_0, 9, 2_8, 0, 2],
               ]  ,			dtype=np.intaa  ,			)

           _UpperCAmelCase    :			Any              =					input_ids.shape[0]
           _UpperCAmelCase    :			List[Any]              =					MBartConfig(
               vocab_size=self.vocab_size  ,			d_model=2_4  ,			encoder_layers=2  ,			decoder_layers=2  ,			encoder_attention_heads=2  ,			decoder_attention_heads=2  ,			encoder_ffn_dim=3_2  ,			decoder_ffn_dim=3_2  ,			max_position_embeddings=4_8  ,			eos_token_id=2  ,			pad_token_id=1  ,			bos_token_id=0  ,			)
           return config, input_ids, batch_size



      def 		snake_case_      (  self  :			Tuple		):
           _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			str              =					self._get_config_and_data()
           _UpperCAmelCase    :			Tuple              =					FlaxMBartForSequenceClassification(A		)
           _UpperCAmelCase    :			Dict              =					model(input_ids=A  ,			decoder_input_ids=A		)
           _UpperCAmelCase    :			Optional[int]              =					(batch_size, config.num_labels)
           self.assertEqual(outputs["logits"].shape  ,			A		)



      def 		snake_case_      (  self  :			Optional[int]		):
           _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			List[str]              =					self._get_config_and_data()
           _UpperCAmelCase    :			Dict              =					FlaxMBartForQuestionAnswering(A		)
           _UpperCAmelCase    :			Dict              =					model(input_ids=A		)

           self.assertEqual(outputs["start_logits"].shape  ,			input_ids.shape		)
           self.assertEqual(outputs["end_logits"].shape  ,			input_ids.shape		)



      def 		snake_case_      (  self  :			str		):
           _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			Optional[Any]              =					self._get_config_and_data()
           _UpperCAmelCase    :			Optional[int]              =					FlaxMBartForConditionalGeneration(A		)
           _UpperCAmelCase    :			Optional[int]              =					lm_model(input_ids=A		)
           _UpperCAmelCase    :			Union[str, Any]              =					(batch_size, input_ids.shape[1], config.vocab_size)
           self.assertEqual(outputs["logits"].shape  ,			A		)



      def 		snake_case_      (  self  :			List[str]		):
           _UpperCAmelCase    :			List[Any]              =					MBartConfig(
               vocab_size=self.vocab_size  ,			d_model=1_4  ,			encoder_layers=2  ,			decoder_layers=2  ,			encoder_attention_heads=2  ,			decoder_attention_heads=2  ,			encoder_ffn_dim=8  ,			decoder_ffn_dim=8  ,			max_position_embeddings=4_8  ,			)
           _UpperCAmelCase    :			Optional[Any]              =					FlaxMBartForConditionalGeneration(A		)
           _UpperCAmelCase    :			Optional[Any]              =					np.array([[7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2], [6_8, 3_4, 2_6, 5_8, 3_0, 2, 1]]  ,			dtype=np.intaa		)
           _UpperCAmelCase    :			Optional[int]              =					np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]  ,			dtype=np.intaa		)
           _UpperCAmelCase    :			str              =					lm_model(input_ids=A  ,			decoder_input_ids=A		)
           _UpperCAmelCase    :			str              =					(*summary.shape, config.vocab_size)
           self.assertEqual(outputs["logits"].shape  ,			A		)



      def 		snake_case_      (  self  :			int		):
           _UpperCAmelCase    :			List[Any]              =					np.array([[7_1, 8_2, 1_8, 3_3, 2, 1, 1], [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2]]  ,			dtype=np.intaa		)
           _UpperCAmelCase    :			Optional[Any]              =					shift_tokens_right(A  ,			1		)
           _UpperCAmelCase    :			Optional[Any]              =					np.equal(A  ,			1		).astype(np.floataa		).sum()
           _UpperCAmelCase    :			int              =					np.equal(A  ,			1		).astype(np.floataa		).sum()
           self.assertEqual(shifted.shape  ,			input_ids.shape		)
           self.assertEqual(A  ,			n_pad_before - 1		)
           self.assertTrue(np.equal(shifted[:, 0]  ,			2		).all()		)







@require_flax
class 			UpperCAmelCase_						(       _UpperCamelCase ,    unittest.TestCase ,    _UpperCamelCase		):
      __SCREAMING_SNAKE_CASE		:     Union[str, Any]				  =				True
      __SCREAMING_SNAKE_CASE		:     List[str]				  =				(
          (
              FlaxMBartModel,
              FlaxMBartForConditionalGeneration,
              FlaxMBartForSequenceClassification,
              FlaxMBartForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )
      __SCREAMING_SNAKE_CASE		:     int				  =				(FlaxMBartForConditionalGeneration,) if is_flax_available() else ()



      def 		snake_case_      (  self  :			List[str]		):
           _UpperCAmelCase    :			Optional[int]              =					FlaxMBartModelTester(self		)



      def 		snake_case_      (  self  :			int		):
           _UpperCAmelCase       , _UpperCAmelCase    :			List[str]              =					self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
                self.model_tester.check_use_cache_forward(A  ,			A  ,			A		)



      def 		snake_case_      (  self  :			List[str]		):
           _UpperCAmelCase       , _UpperCAmelCase    :			List[str]              =					self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
                self.model_tester.check_use_cache_forward_with_attn_mask(A  ,			A  ,			A		)



      def 		snake_case_      (  self  :			Any		):
           _UpperCAmelCase       , _UpperCAmelCase    :			Optional[int]              =					self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                with self.subTest(model_class.__name__		):
                     _UpperCAmelCase    :			Optional[int]              =					self._prepare_for_class(A  ,			A		)
                     _UpperCAmelCase    :			Tuple              =					model_class(A		)

                     @jax.jit
                     def encode_jitted(A  :			Any  ,			A  :			List[Any]=None  ,			**A  :			Any		):
                          return model.encode(input_ids=A  ,			attention_mask=A		)

                     with self.subTest("JIT Enabled"		):
                          _UpperCAmelCase    :			Optional[Any]              =					encode_jitted(**A		).to_tuple()

                     with self.subTest("JIT Disabled"		):
                          with jax.disable_jit():
                               _UpperCAmelCase    :			Any              =					encode_jitted(**A		).to_tuple()

                     self.assertEqual(len(A		)  ,			len(A		)		)
                     for jitted_output, output in zip(A  ,			A		):
                          self.assertEqual(jitted_output.shape  ,			output.shape		)



      def 		snake_case_      (  self  :			List[Any]		):
           _UpperCAmelCase       , _UpperCAmelCase    :			Optional[Any]              =					self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                with self.subTest(model_class.__name__		):
                     _UpperCAmelCase    :			Optional[Any]              =					model_class(A		)
                     _UpperCAmelCase    :			Optional[int]              =					model.encode(inputs_dict["input_ids"]  ,			inputs_dict["attention_mask"]		)

                     _UpperCAmelCase    :			Union[str, Any]              =					{
                         "decoder_input_ids": inputs_dict["decoder_input_ids"],
                         "decoder_attention_mask": inputs_dict["decoder_attention_mask"],
                         "encoder_outputs": encoder_outputs,
                     }

                     @jax.jit
                     def decode_jitted(A  :			List[Any]  ,			A  :			Tuple  ,			A  :			Optional[Any]		):
                          return model.decode(
                              decoder_input_ids=A  ,			decoder_attention_mask=A  ,			encoder_outputs=A  ,			)

                     with self.subTest("JIT Enabled"		):
                          _UpperCAmelCase    :			Optional[int]              =					decode_jitted(**A		).to_tuple()

                     with self.subTest("JIT Disabled"		):
                          with jax.disable_jit():
                               _UpperCAmelCase    :			Optional[int]              =					decode_jitted(**A		).to_tuple()

                     self.assertEqual(len(A		)  ,			len(A		)		)
                     for jitted_output, output in zip(A  ,			A		):
                          self.assertEqual(jitted_output.shape  ,			output.shape		)



      @slow
      def 		snake_case_      (  self  :			List[str]		):
           for model_class_name in self.all_model_classes:
                _UpperCAmelCase    :			str              =					model_class_name.from_pretrained("facebook/mbart-large-cc25"  ,			from_pt=A		)
                # FlaxMBartForSequenceClassification expects eos token in input_ids
                _UpperCAmelCase    :			Optional[int]              =					np.ones((1, 1)		) * model.config.eos_token_id
                _UpperCAmelCase    :			str              =					model(A		)
                self.assertIsNotNone(A		)







@require_flax
@require_sentencepiece
@require_tokenizers
class 			UpperCAmelCase_						(       unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:     Dict				  =				[
          ' UN Chief Says There Is No Military Solution in Syria',
      ]
      __SCREAMING_SNAKE_CASE		:     Optional[int]				  =				[
          'Şeful ONU declară că nu există o soluţie militară în Siria',
      ]
      __SCREAMING_SNAKE_CASE		:     str				  =				'facebook/mbart-large-en-ro'



      @cached_property
      def 		snake_case_      (  self  :			int		):
           return AutoTokenizer.from_pretrained(self.model_name		)



      @cached_property
      def 		snake_case_      (  self  :			Any		):
           _UpperCAmelCase    :			Tuple              =					FlaxMBartForConditionalGeneration.from_pretrained(self.model_name  ,			from_pt=A		)
           return model



      def 		snake_case_      (  self  :			Union[str, Any]  ,			**A  :			Union[str, Any]		):
           _UpperCAmelCase    :			Optional[int]              =					self.translate_src_text(**A		)
           self.assertListEqual(self.expected_text  ,			A		)



      def 		snake_case_      (  self  :			Any  ,			**A  :			int		):
           _UpperCAmelCase    :			int              =					self.tokenizer(self.src_text  ,			**A  ,			return_tensors="np"		)
           _UpperCAmelCase    :			Optional[Any]              =					self.model.generate(
               model_inputs.input_ids  ,			attention_mask=model_inputs.attention_mask  ,			decoder_start_token_id=self.tokenizer.lang_code_to_id["ro_RO"]  ,			early_stopping=A  ,			num_beams=2  ,			).sequences
           _UpperCAmelCase    :			Optional[int]              =					self.tokenizer.batch_decode(A  ,			skip_special_tokens=A		)
           return generated_words



      @slow
      def 		snake_case_      (  self  :			Union[str, Any]		):
           self._assert_generated_batch_equal_expected()





"""simple docstring"""




def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		list       )						->     bool:





     '''simple docstring'''

     if not isinstance(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       ):
          raise ValueError("Input series is not valid, valid series - [1, 2/3, 2]"       )
     if len(SCREAMING_SNAKE_CASE__       ) == 0:
          raise ValueError("Input list must be a non empty list"       )
     if len(SCREAMING_SNAKE_CASE__       ) == 1 and series[0] != 0:
          return True
     _UpperCAmelCase    :			Tuple              =					[]
     _UpperCAmelCase    :			Any              =					len(SCREAMING_SNAKE_CASE__       )
     for i in range(0		,						SCREAMING_SNAKE_CASE__       ):
          if series[i] == 0:
               raise ValueError("Input series cannot have 0 as an element"       )
          rec_series.append(1 / series[i]       )
     _UpperCAmelCase    :			Dict              =					rec_series[1] - rec_series[0]
     for index in range(2		,						SCREAMING_SNAKE_CASE__       ):
          if rec_series[index] - rec_series[index - 1] != common_diff:
               return False
     return True

def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		list       )						->     float:





     '''simple docstring'''

     if not isinstance(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       ):
          raise ValueError("Input series is not valid, valid series - [2, 4, 6]"       )
     if len(SCREAMING_SNAKE_CASE__       ) == 0:
          raise ValueError("Input list must be a non empty list"       )
     _UpperCAmelCase    :			Any              =					0
     for val in series:
          answer += 1 / val
     return len(SCREAMING_SNAKE_CASE__       ) / answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()
