code: 
  
  
  
  
  
  
  import unittest
  from unittest.util import safe_repr
  
  from transformers import AutoTokenizer, RwkvConfig, is_torch_available
  from transformers.testing_utils import require_torch, slow, torch_device
  
  from ...generation.test_utils import GenerationTesterMixin
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
        import torch
  
        from transformers import (
            RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
            RwkvForCausalLM,
            RwkvModel,
        )
        from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
  else:
        SCREAMING_SNAKE_CASE__		:       Union[str, Any]												=							False
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase=14  ,	_lowerCAmelCase=7  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=False  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=99  ,	_lowerCAmelCase=32  ,	_lowerCAmelCase=5  ,	_lowerCAmelCase=37  ,	_lowerCAmelCase="gelu"  ,	_lowerCAmelCase=0.1  ,	_lowerCAmelCase=0.1  ,	_lowerCAmelCase=512  ,	_lowerCAmelCase=16  ,	_lowerCAmelCase=2  ,	_lowerCAmelCase=3  ,	_lowerCAmelCase=4  ,	_lowerCAmelCase=None  ,	):
            UpperCAmelCase__			:     Union[str, Any]										= parent
            UpperCAmelCase__			:     List[str]										= batch_size
            UpperCAmelCase__			:     List[str]										= seq_length
            UpperCAmelCase__			:     Any										= is_training
            UpperCAmelCase__			:     List[Any]										= use_token_type_ids
            UpperCAmelCase__			:     List[Any]										= use_input_mask
            UpperCAmelCase__			:     Optional[Any]										= use_labels
            UpperCAmelCase__			:     Tuple										= use_mc_token_ids
            UpperCAmelCase__			:     Any										= vocab_size
            UpperCAmelCase__			:     str										= hidden_size
            UpperCAmelCase__			:     Any										= num_hidden_layers
            UpperCAmelCase__			:     int										= intermediate_size
            UpperCAmelCase__			:     Tuple										= hidden_act
            UpperCAmelCase__			:     Dict										= hidden_dropout_prob
            UpperCAmelCase__			:     Any										= attention_probs_dropout_prob
            UpperCAmelCase__			:     str										= max_position_embeddings
            UpperCAmelCase__			:     Dict										= type_vocab_size
            UpperCAmelCase__			:     Any										= type_sequence_label_size
            UpperCAmelCase__			:     Any										= num_labels
            UpperCAmelCase__			:     Optional[int]										= num_choices
            UpperCAmelCase__			:     Optional[Any]										= scope
            UpperCAmelCase__			:     List[str]										= vocab_size - 1
            UpperCAmelCase__			:     str										= vocab_size - 1
            UpperCAmelCase__			:     Union[str, Any]										= vocab_size - 1
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            return RwkvConfig.from_pretrained("""sgugger/rwkv-4-pile-7b"""		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase=False  ,	_lowerCAmelCase=False  ,	_lowerCAmelCase=False		):
            UpperCAmelCase__			:     Optional[Any]										= ids_tensor([self.batch_size, self.seq_length]  ,	self.vocab_size		)
  
            UpperCAmelCase__			:     Optional[Any]										= None
            if self.use_input_mask:
                 UpperCAmelCase__			:     str										= random_attention_mask([self.batch_size, self.seq_length]		)
  
            UpperCAmelCase__			:     Optional[Any]										= None
            if self.use_token_type_ids:
                 UpperCAmelCase__			:     Tuple										= ids_tensor([self.batch_size, self.seq_length]  ,	self.type_vocab_size		)
  
            UpperCAmelCase__			:     Any										= None
            if self.use_mc_token_ids:
                 UpperCAmelCase__			:     Optional[int]										= ids_tensor([self.batch_size, self.num_choices]  ,	self.seq_length		)
  
            UpperCAmelCase__			:     List[str]										= None
            UpperCAmelCase__			:     Dict										= None
            UpperCAmelCase__			:     Optional[Any]										= None
            if self.use_labels:
                 UpperCAmelCase__			:     List[Any]										= ids_tensor([self.batch_size]  ,	self.type_sequence_label_size		)
                 UpperCAmelCase__			:     Dict										= ids_tensor([self.batch_size, self.seq_length]  ,	self.num_labels		)
                 UpperCAmelCase__			:     Optional[Any]										= ids_tensor([self.batch_size]  ,	self.num_choices		)
  
            UpperCAmelCase__			:     int										= self.get_config(
                gradient_checkpointing=lowerCAmelCase_  ,	scale_attn_by_inverse_layer_idx=lowerCAmelCase_  ,	reorder_and_upcast_attn=lowerCAmelCase_  ,	)
  
            return (
                config,
                input_ids,
                input_mask,
                None,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase=False  ,	_lowerCAmelCase=False  ,	_lowerCAmelCase=False		):
            return RwkvConfig(
                vocab_size=self.vocab_size  ,	hidden_size=self.hidden_size  ,	num_hidden_layers=self.num_hidden_layers  ,	intermediate_size=self.intermediate_size  ,	activation_function=self.hidden_act  ,	resid_pdrop=self.hidden_dropout_prob  ,	attn_pdrop=self.attention_probs_dropout_prob  ,	n_positions=self.max_position_embeddings  ,	type_vocab_size=self.type_vocab_size  ,	use_cache=lowerCAmelCase_  ,	bos_token_id=self.bos_token_id  ,	eos_token_id=self.eos_token_id  ,	pad_token_id=self.pad_token_id  ,	gradient_checkpointing=lowerCAmelCase_  ,	scale_attn_by_inverse_layer_idx=lowerCAmelCase_  ,	reorder_and_upcast_attn=lowerCAmelCase_  ,	)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Any										= self.get_config()
            UpperCAmelCase__			:     Any										= 300
            return config
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            (
                (
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		
            )			:     Dict										= self.prepare_config_and_inputs()
  
            UpperCAmelCase__			:     Tuple										= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
            UpperCAmelCase__			:     int										= ids_tensor([self.batch_size, self.seq_length]  ,	vocab_size=2		)
  
            return (
                config,
                input_ids,
                input_mask,
                head_mask,
                token_type_ids,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	*_lowerCAmelCase		):
            UpperCAmelCase__			:     Tuple										= True
            UpperCAmelCase__			:     List[str]										= RwkvModel(config=lowerCAmelCase_		)
            model.to(lowerCAmelCase_		)
            model.eval()
  
            UpperCAmelCase__			:     Union[str, Any]										= model(lowerCAmelCase_		)
  
            self.parent.assertEqual(result.last_hidden_state.shape  ,	(self.batch_size, self.seq_length, self.hidden_size)		)
            self.parent.assertEqual(len(result.hidden_states		)  ,	config.num_hidden_layers + 1		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	*_lowerCAmelCase		):
            UpperCAmelCase__			:     str										= RwkvForCausalLM(lowerCAmelCase_		)
            model.to(lowerCAmelCase_		)
            model.eval()
  
            UpperCAmelCase__			:     Optional[int]										= model(lowerCAmelCase_  ,	labels=lowerCAmelCase_		)
            self.parent.assertEqual(result.loss.shape  ,	()		)
            self.parent.assertEqual(result.logits.shape  ,	(self.batch_size, self.seq_length, self.vocab_size)		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	*_lowerCAmelCase		):
            UpperCAmelCase__			:     int										= RwkvModel(config=lowerCAmelCase_		)
            model.to(lowerCAmelCase_		)
            model.eval()
  
            UpperCAmelCase__			:     Union[str, Any]										= model(lowerCAmelCase_		)
            UpperCAmelCase__			:     Optional[int]										= outputs.last_hidden_state
  
            UpperCAmelCase__			:     List[Any]										= model(input_ids[:, :2]		)
            UpperCAmelCase__			:     Union[str, Any]										= outputs.last_hidden_state
  
            # Using the state computed on the first inputs, we will get the same output
            UpperCAmelCase__			:     Optional[int]										= model(input_ids[:, 2:]  ,	state=outputs.state		)
            UpperCAmelCase__			:     int										= outputs.last_hidden_state
  
            self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]  ,	dim=1		)  ,	lowerCAmelCase_  ,	atol=1e-5		)		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	*_lowerCAmelCase  ,	_lowerCAmelCase=False		):
            UpperCAmelCase__			:     Optional[Any]										= RwkvForCausalLM(lowerCAmelCase_		)
            model.to(lowerCAmelCase_		)
            if gradient_checkpointing:
                 model.gradient_checkpointing_enable()
  
            UpperCAmelCase__			:     List[str]										= model(lowerCAmelCase_  ,	labels=lowerCAmelCase_		)
            self.parent.assertEqual(result.loss.shape  ,	()		)
            self.parent.assertEqual(result.logits.shape  ,	(self.batch_size, self.seq_length, self.vocab_size)		)
            result.loss.backward()
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Optional[Any]										= self.prepare_config_and_inputs()
  
            (
                (
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		(
                UpperCAmelCase__
            )			,		
            )			:     int										= config_and_inputs
  
            UpperCAmelCase__			:     Dict										= {"""input_ids""": input_ids}
  
            return config, inputs_dict
  
  
  
  
  
  
  
  @unittest.skipIf(
      not is_torch_greater_or_equal_than_2_0       ,			reason='See https://github.com/huggingface/transformers/pull/24204'		)
  @require_torch
  class 							UpperCAmelCase_     (		lowerCAmelCase__       ,			lowerCAmelCase__       ,			lowerCAmelCase__       ,			unittest.TestCase		):
       __lowerCamelCase										=     (RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
       __lowerCamelCase										=     (
           {"""feature-extraction""": RwkvModel, """text-generation""": RwkvForCausalLM} if is_torch_available() else {}
       )
       # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
       __lowerCamelCase										=     False
       __lowerCamelCase										=     False
       __lowerCamelCase										=     False
       __lowerCamelCase										=     False
       __lowerCamelCase										=     False  # Rwkv does not support head masking
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Optional[Any]										= RwkvModelTester(self		)
            UpperCAmelCase__			:     Any										= ConfigTester(
                self  ,	config_class=lowerCAmelCase_  ,	n_embd=37  ,	common_properties=["""hidden_size""", """num_hidden_layers"""]		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase=None		):
  
  
  
  
  
  
            if isinstance(lowerCAmelCase_  ,	torch.Tensor		):
                 UpperCAmelCase__			,		UpperCAmelCase__			:     str										= member.max().item(), member.min().item()
            elif isinstance(lowerCAmelCase_  ,	lowerCAmelCase_		) or isinstance(lowerCAmelCase_  ,	lowerCAmelCase_		):
                 UpperCAmelCase__			,		UpperCAmelCase__			:     Union[str, Any]										= max(lowerCAmelCase_		), min(lowerCAmelCase_		)
  
            if not isinstance(lowerCAmelCase_  ,	lowerCAmelCase_		):
                 raise TypeError("""container should be a list or tuple"""		)
            elif len(lowerCAmelCase_		) != 2:
                 raise ValueError("""container should have 2 elements"""		)
  
            UpperCAmelCase__			,		UpperCAmelCase__			:     Tuple										= container
  
            UpperCAmelCase__			:     Optional[int]										= (min_value >= expected_min) and (max_value <= expected_max)
  
            if not is_inside_interval:
                 UpperCAmelCase__			:     List[str]										= """%s not found in %s""" % (safe_repr(lowerCAmelCase_		), safe_repr(lowerCAmelCase_		))
                 self.fail(self._formatMessage(lowerCAmelCase_  ,	lowerCAmelCase_		)		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            self.config_tester.run_common_tests()
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Dict										= self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_rwkv_model(*lowerCAmelCase_		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     List[Any]										= self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_causl_lm(*lowerCAmelCase_		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Any										= self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_state_equivalency(*lowerCAmelCase_		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			,		UpperCAmelCase__			:     Tuple										= self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
                 UpperCAmelCase__			:     List[Any]										= model_class(config=lowerCAmelCase_		)
                 for name, param in model.named_parameters():
                      if "time_decay" in name:
                           if param.requires_grad:
                                self.assertTrue(param.data.max().item() == 3.0		)
                                self.assertTrue(param.data.min().item() == -5.0		)
                      elif "time_first" in name:
                           if param.requires_grad:
                                # check if it's a ones like
                                self.assertTrue(torch.allclose(param.data  ,	torch.ones_like(param.data		)  ,	atol=1e-5  ,	rtol=1e-5		)		)
                      elif any(x in name for x in ["""time_mix_key""", """time_mix_receptance"""]		):
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data  ,	[0.0, 1.0]  ,	msg=f"Parameter {name} of model {model_class} seems not properly initialized"  ,	)
                      elif "time_mix_value" in name:
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data  ,	[0.0, 1.3]  ,	msg=f"Parameter {name} of model {model_class} seems not properly initialized"  ,	)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			,		UpperCAmelCase__			:     str										= self.model_tester.prepare_config_and_inputs_for_common()
            UpperCAmelCase__			:     Dict										= True
  
            UpperCAmelCase__			:     List[Any]										= getattr(self.model_tester  ,	"""seq_length"""  ,	lowerCAmelCase_		)
  
            for model_class in self.all_model_classes:
                 UpperCAmelCase__			:     str										= True
                 UpperCAmelCase__			:     Any										= False
                 UpperCAmelCase__			:     str										= True
                 UpperCAmelCase__			:     Any										= model_class(lowerCAmelCase_		)
                 model.to(lowerCAmelCase_		)
                 model.eval()
  
                 UpperCAmelCase__			:     Optional[int]										= self._prepare_for_class(lowerCAmelCase_  ,	lowerCAmelCase_		)
                 UpperCAmelCase__			:     List[str]										= inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      UpperCAmelCase__			:     List[str]										= model(**lowerCAmelCase_		)
                 UpperCAmelCase__			:     int										= outputs.attentions
                 self.assertEqual(len(lowerCAmelCase_		)  ,	self.model_tester.num_hidden_layers		)
  
                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 UpperCAmelCase__			:     List[str]										= True
                 UpperCAmelCase__			:     Union[str, Any]										= model_class(lowerCAmelCase_		)
                 model.to(lowerCAmelCase_		)
                 model.eval()
  
                 UpperCAmelCase__			:     str										= self._prepare_for_class(lowerCAmelCase_  ,	lowerCAmelCase_		)
                 UpperCAmelCase__			:     Optional[int]										= inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      UpperCAmelCase__			:     List[Any]										= model(**lowerCAmelCase_		)
                 UpperCAmelCase__			:     Optional[Any]										= outputs.attentions
                 self.assertEqual(len(lowerCAmelCase_		)  ,	self.model_tester.num_hidden_layers		)
  
                 self.assertListEqual(
                     list(attentions[0].shape[-3:]		)  ,	[batch_size, seq_len, config.hidden_size]  ,	)
                 UpperCAmelCase__			:     List[str]										= len(lowerCAmelCase_		)
  
                 # Check attention is always last and order is fine
                 UpperCAmelCase__			:     List[Any]										= True
                 UpperCAmelCase__			:     Optional[int]										= True
                 UpperCAmelCase__			:     Optional[int]										= model_class(lowerCAmelCase_		)
                 model.to(lowerCAmelCase_		)
                 model.eval()
  
                 UpperCAmelCase__			:     int										= self._prepare_for_class(lowerCAmelCase_  ,	lowerCAmelCase_		)
                 UpperCAmelCase__			:     Union[str, Any]										= inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      UpperCAmelCase__			:     List[Any]										= model(**lowerCAmelCase_		)
  
                 UpperCAmelCase__			:     Dict										= 1
                 self.assertEqual(out_len + added_hidden_states  ,	len(lowerCAmelCase_		)		)
  
                 UpperCAmelCase__			:     Any										= outputs.attentions
  
                 self.assertEqual(len(lowerCAmelCase_		)  ,	self.model_tester.num_hidden_layers		)
                 self.assertListEqual(
                     list(self_attentions[0].shape[-3:]		)  ,	[batch_size, seq_len, config.hidden_size]  ,	)
  
  
  
  
       @slow
       def      __UpperCAmelCase     (							self		):
  
  
  
  
  
  
            for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 UpperCAmelCase__			:     Any										= RwkvModel.from_pretrained(lowerCAmelCase_		)
                 self.assertIsNotNone(lowerCAmelCase_		)
  
  
  
  
  
  
  
  @unittest.skipIf(
      not is_torch_greater_or_equal_than_2_0       ,			reason='See https://github.com/huggingface/transformers/pull/24204'		)
  @slow
  class 							UpperCAmelCase_     (		unittest.TestCase		):
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Tuple										= """RWKV/rwkv-4-169m-pile"""
            UpperCAmelCase__			:     int										= AutoTokenizer.from_pretrained(self.model_id		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Optional[Any]										= """Hello my name is Jasmine and I am a newbie to the"""
            UpperCAmelCase__			:     int										= RwkvForCausalLM.from_pretrained(self.model_id		).to(lowerCAmelCase_		)
  
            UpperCAmelCase__			:     Optional[Any]										= self.tokenizer("""Hello my name is"""  ,	return_tensors="""pt"""		).input_ids.to(lowerCAmelCase_		)
            UpperCAmelCase__			:     Optional[Any]										= model.generate(lowerCAmelCase_  ,	max_new_tokens=10		)
            UpperCAmelCase__			:     int										= self.tokenizer.decode(output[0].tolist()		)
  
            self.assertEqual(lowerCAmelCase_  ,	lowerCAmelCase_		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     str										= """Hello my name is Jasmine and I am a newbie to the"""
  
            UpperCAmelCase__			:     Optional[int]										= self.tokenizer("""Hello my name is"""  ,	return_tensors="""pt"""		).input_ids.to(lowerCAmelCase_		)
            UpperCAmelCase__			:     int										= RwkvForCausalLM.from_pretrained(self.model_id  ,	torch_dtype=torch.bfloataa		).to(lowerCAmelCase_		)
  
            UpperCAmelCase__			:     Dict										= model.generate(lowerCAmelCase_  ,	max_new_tokens=10		)
            UpperCAmelCase__			:     Dict										= self.tokenizer.decode(output[0].tolist()		)
  
            self.assertEqual(lowerCAmelCase_  ,	lowerCAmelCase_		)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase		):
            UpperCAmelCase__			:     List[Any]										= value
            UpperCAmelCase__			:     Node | None										= None
            UpperCAmelCase__			:     Node | None										= None
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
       __lowerCamelCase										=     42
  
  
  
  
       def __init__(							self		):
            UpperCAmelCase__			:     Any										= 0
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase		):
            if node is None:
                 return
  
            if path_sum == self.target:
                 self.paths += 1
  
            if node.left:
                 self.depth_first_search(node.left  ,	path_sum + node.left.value		)
            if node.right:
                 self.depth_first_search(node.right  ,	path_sum + node.right.value		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase = None		):
            if node is None:
                 return 0
            if target is not None:
                 UpperCAmelCase__			:     List[Any]										= target
  
            self.depth_first_search(_lowerCAmelCase  ,	node.value		)
            self.path_sum(node.left		)
            self.path_sum(node.right		)
  
            return self.paths
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
  
  
  
  
  
  
  