code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  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:
      A_			  =    False
  class 						__lowerCAmelCase   :
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		List[Any]				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		List[str]=14				,			UpperCamelCase_:		int=7				,			UpperCamelCase_:		Union[str, Any]=True				,			UpperCamelCase_:		Optional[int]=False				,			UpperCamelCase_:		Optional[Any]=True				,			UpperCamelCase_:		List[str]=True				,			UpperCamelCase_:		Any=True				,			UpperCamelCase_:		List[str]=99				,			UpperCamelCase_:		Optional[Any]=32				,			UpperCamelCase_:		int=5				,			UpperCamelCase_:		Optional[Any]=37				,			UpperCamelCase_:		Union[str, Any]="gelu"				,			UpperCamelCase_:		Any=0.1				,			UpperCamelCase_:		List[Any]=0.1				,			UpperCamelCase_:		Union[str, Any]=512				,			UpperCamelCase_:		str=16				,			UpperCamelCase_:		List[str]=2				,			UpperCamelCase_:		Optional[int]=3				,			UpperCamelCase_:		Tuple=4				,			UpperCamelCase_:		Tuple=None				,			):
       UpperCamelCase_     =parent
       UpperCamelCase_     =batch_size
       UpperCamelCase_     =seq_length
       UpperCamelCase_     =is_training
       UpperCamelCase_     =use_token_type_ids
       UpperCamelCase_     =use_input_mask
       UpperCamelCase_     =use_labels
       UpperCamelCase_     =use_mc_token_ids
       UpperCamelCase_     =vocab_size
       UpperCamelCase_     =hidden_size
       UpperCamelCase_     =num_hidden_layers
       UpperCamelCase_     =intermediate_size
       UpperCamelCase_     =hidden_act
       UpperCamelCase_     =hidden_dropout_prob
       UpperCamelCase_     =attention_probs_dropout_prob
       UpperCamelCase_     =max_position_embeddings
       UpperCamelCase_     =type_vocab_size
       UpperCamelCase_     =type_sequence_label_size
       UpperCamelCase_     =num_labels
       UpperCamelCase_     =num_choices
       UpperCamelCase_     =scope
       UpperCamelCase_     =vocab_size - 1
       UpperCamelCase_     =vocab_size - 1
       UpperCamelCase_     =vocab_size - 1
    def 					UpperCamelCase__   (      self:		int					):
       return RwkvConfig.from_pretrained("sgugger/rwkv-4-pile-7b"					)
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		List[str]=False				,			UpperCamelCase_:		str=False				,			UpperCamelCase_:		Dict=False					):
       UpperCamelCase_     =ids_tensor([self.batch_size, self.seq_length]				,			self.vocab_size					)
  
       UpperCamelCase_     =None
       if self.use_input_mask:
          UpperCamelCase_     =random_attention_mask([self.batch_size, self.seq_length]					)
  
       UpperCamelCase_     =None
       if self.use_token_type_ids:
          UpperCamelCase_     =ids_tensor([self.batch_size, self.seq_length]				,			self.type_vocab_size					)
  
       UpperCamelCase_     =None
       if self.use_mc_token_ids:
          UpperCamelCase_     =ids_tensor([self.batch_size, self.num_choices]				,			self.seq_length					)
  
       UpperCamelCase_     =None
       UpperCamelCase_     =None
       UpperCamelCase_     =None
       if self.use_labels:
          UpperCamelCase_     =ids_tensor([self.batch_size]				,			self.type_sequence_label_size					)
          UpperCamelCase_     =ids_tensor([self.batch_size, self.seq_length]				,			self.num_labels					)
          UpperCamelCase_     =ids_tensor([self.batch_size]				,			self.num_choices					)
  
       UpperCamelCase_     =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:		str				,			UpperCamelCase_:		List[str]=False				,			UpperCamelCase_:		Any=False				,			UpperCamelCase_:		Optional[Any]=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:		int					):
       UpperCamelCase_     =self.get_config()
       UpperCamelCase_     =300
       return config
    def 					UpperCamelCase__   (      self:		Dict					):
       (
           (
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							
       )     =self.prepare_config_and_inputs()
  
       UpperCamelCase_     =floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
       UpperCamelCase_     =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:		str				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		Any				,			UpperCamelCase_:		Any				,			UpperCamelCase_:		Tuple				,			*UpperCamelCase_:		Dict					):
       UpperCamelCase_     =True
       UpperCamelCase_     =RwkvModel(config=lowerCAmelCase_					)
       model.to(lowerCAmelCase_					)
       model.eval()
  
       UpperCamelCase_     =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:		Optional[int]				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		Dict				,			UpperCamelCase_:		Optional[Any]				,			UpperCamelCase_:		Optional[Any]				,			*UpperCamelCase_:		List[str]					):
       UpperCamelCase_     =RwkvForCausalLM(lowerCAmelCase_					)
       model.to(lowerCAmelCase_					)
       model.eval()
  
       UpperCamelCase_     =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:		Dict				,			UpperCamelCase_:		Optional[Any]				,			UpperCamelCase_:		Dict				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		int				,			*UpperCamelCase_:		Tuple					):
       UpperCamelCase_     =RwkvModel(config=lowerCAmelCase_					)
       model.to(lowerCAmelCase_					)
       model.eval()
  
       UpperCamelCase_     =model(lowerCAmelCase_					)
       UpperCamelCase_     =outputs.last_hidden_state
  
       UpperCamelCase_     =model(input_ids[:, :2]					)
       UpperCamelCase_     =outputs.last_hidden_state
  
       # Using the state computed on the first inputs, we will get the same output
       UpperCamelCase_     =model(input_ids[:, 2:]				,			state=outputs.state					)
       UpperCamelCase_     =outputs.last_hidden_state
  
       self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]				,			dim=1					)				,			lowerCAmelCase_				,			atol=1e-5					)					)
    def 					UpperCamelCase__   (      self:		Union[str, Any]				,			UpperCamelCase_:		int				,			UpperCamelCase_:		Tuple				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		Union[str, Any]				,			*UpperCamelCase_:		int				,			UpperCamelCase_:		str=False					):
       UpperCamelCase_     =RwkvForCausalLM(lowerCAmelCase_					)
       model.to(lowerCAmelCase_					)
       if gradient_checkpointing:
          model.gradient_checkpointing_enable()
  
       UpperCamelCase_     =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:		List[Any]					):
       UpperCamelCase_     =self.prepare_config_and_inputs()
  
       (
           (
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							(
           UpperCamelCase_
       )    ,							
       )     =config_and_inputs
  
       UpperCamelCase_     ={"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 						__lowerCAmelCase   (			lowerCAmelCase__       ,   lowerCAmelCase__       ,   lowerCAmelCase__       ,   unittest.TestCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    str     	=			(RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
    __lowerCamelCase       :    Union[str, Any]     	=			(
        {"""feature-extraction""": RwkvModel, """text-generation""": RwkvForCausalLM} if is_torch_available() else {}
    )
    # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
    __lowerCamelCase       :    Optional[Any]     	=			False
    __lowerCamelCase       :    Optional[Any]     	=			False
    __lowerCamelCase       :    int     	=			False
    __lowerCamelCase       :    List[Any]     	=			False
    __lowerCamelCase       :    Tuple     	=			False  # Rwkv does not support head masking
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       UpperCamelCase_     =RwkvModelTester(self					)
       UpperCamelCase_     =ConfigTester(
           self				,			config_class=lowerCAmelCase_				,			n_embd=37				,			common_properties=["hidden_size", "num_hidden_layers"]					)
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		str				,			UpperCamelCase_:		int=None					):
  
  
  
  
  
  
       if isinstance(lowerCAmelCase_				,			torch.Tensor					):
          UpperCamelCase_    ,							UpperCamelCase_     =member.max().item(), member.min().item()
       elif isinstance(lowerCAmelCase_				,			lowerCAmelCase_					) or isinstance(lowerCAmelCase_				,			lowerCAmelCase_					):
          UpperCamelCase_    ,							UpperCamelCase_     =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_     =container
  
       UpperCamelCase_     =(min_value >= expected_min) and (max_value <= expected_max)
  
       if not is_inside_interval:
          UpperCamelCase_     ="%s not found in %s" % (safe_repr(lowerCAmelCase_					), safe_repr(lowerCAmelCase_					))
          self.fail(self._formatMessage(lowerCAmelCase_				,			lowerCAmelCase_					)					)
    def 					UpperCamelCase__   (      self:		List[str]					):
       self.config_tester.run_common_tests()
    def 					UpperCamelCase__   (      self:		Dict					):
       UpperCamelCase_     =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_rwkv_model(*lowerCAmelCase_					)
    def 					UpperCamelCase__   (      self:		Union[str, Any]					):
       UpperCamelCase_     =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_causl_lm(*lowerCAmelCase_					)
    def 					UpperCamelCase__   (      self:		List[str]					):
       UpperCamelCase_     =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_state_equivalency(*lowerCAmelCase_					)
    def 					UpperCamelCase__   (      self:		List[Any]					):
       UpperCamelCase_    ,							UpperCamelCase_     =self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
          UpperCamelCase_     =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:		List[str]					):
       UpperCamelCase_    ,							UpperCamelCase_     =self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase_     =True
  
       UpperCamelCase_     =getattr(self.model_tester				,			"seq_length"				,			lowerCAmelCase_					)
  
       for model_class in self.all_model_classes:
          UpperCamelCase_     =True
          UpperCamelCase_     =False
          UpperCamelCase_     =True
          UpperCamelCase_     =model_class(lowerCAmelCase_					)
          model.to(lowerCAmelCase_					)
          model.eval()
  
          UpperCamelCase_     =self._prepare_for_class(lowerCAmelCase_				,			lowerCAmelCase_					)
          UpperCamelCase_     =inputs["input_ids"].shape[0]
          with torch.no_grad():
             UpperCamelCase_     =model(**lowerCAmelCase_					)
          UpperCamelCase_     =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_     =True
          UpperCamelCase_     =model_class(lowerCAmelCase_					)
          model.to(lowerCAmelCase_					)
          model.eval()
  
          UpperCamelCase_     =self._prepare_for_class(lowerCAmelCase_				,			lowerCAmelCase_					)
          UpperCamelCase_     =inputs["input_ids"].shape[0]
          with torch.no_grad():
             UpperCamelCase_     =model(**lowerCAmelCase_					)
          UpperCamelCase_     =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_     =len(lowerCAmelCase_					)
  
          # Check attention is always last and order is fine
          UpperCamelCase_     =True
          UpperCamelCase_     =True
          UpperCamelCase_     =model_class(lowerCAmelCase_					)
          model.to(lowerCAmelCase_					)
          model.eval()
  
          UpperCamelCase_     =self._prepare_for_class(lowerCAmelCase_				,			lowerCAmelCase_					)
          UpperCamelCase_     =inputs["input_ids"].shape[0]
          with torch.no_grad():
             UpperCamelCase_     =model(**lowerCAmelCase_					)
  
          UpperCamelCase_     =1
          self.assertEqual(out_len + added_hidden_states				,			len(lowerCAmelCase_					)					)
  
          UpperCamelCase_     =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:		List[str]					):
  
  
  
  
  
  
       for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          UpperCamelCase_     =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 						__lowerCAmelCase   (			unittest.TestCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def 					UpperCamelCase__   (      self:		Dict					):
       UpperCamelCase_     ="RWKV/rwkv-4-169m-pile"
       UpperCamelCase_     =AutoTokenizer.from_pretrained(self.model_id					)
    def 					UpperCamelCase__   (      self:		List[str]					):
       UpperCamelCase_     ="Hello my name is Jasmine and I am a newbie to the"
       UpperCamelCase_     =RwkvForCausalLM.from_pretrained(self.model_id					).to(lowerCAmelCase_					)
  
       UpperCamelCase_     =self.tokenizer("Hello my name is"				,			return_tensors="pt"					).input_ids.to(lowerCAmelCase_					)
       UpperCamelCase_     =model.generate(lowerCAmelCase_				,			max_new_tokens=10					)
       UpperCamelCase_     =self.tokenizer.decode(output[0].tolist()					)
  
       self.assertEqual(lowerCAmelCase_				,			lowerCAmelCase_					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[int]					):
       UpperCamelCase_     ="Hello my name is Jasmine and I am a newbie to the"
  
       UpperCamelCase_     =self.tokenizer("Hello my name is"				,			return_tensors="pt"					).input_ids.to(lowerCAmelCase_					)
       UpperCamelCase_     =RwkvForCausalLM.from_pretrained(self.model_id				,			torch_dtype=torch.bfloataa					).to(lowerCAmelCase_					)
  
       UpperCamelCase_     =model.generate(lowerCAmelCase_				,			max_new_tokens=10					)
       UpperCamelCase_     =self.tokenizer.decode(output[0].tolist()					)
  
       self.assertEqual(lowerCAmelCase_				,			lowerCAmelCase_					)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from datetime import date
  
  import requests
  
  A_			  =    "https://api.carbonintensity.org.uk/intensity"
  
  
  
  
  def 						_UpperCamelCase			(  ):
     UpperCamelCase_     =requests.get(A			).json()["data"][0]
     return last_half_hour["intensity"]["actual"]
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     return requests.get(f"""{BASE_URL}/{start}/{end}"""			).json()["data"]
  
  
  if __name__ == "__main__":
      for entry in fetch_from_to(start=date(2020, 10, 1), end=date(2020, 10, 3)):
          print("from {from} to {to}: {intensity[actual]}".format(**entry))
      print(f'''{fetch_last_half_hour() = }''')
  