





import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM





@require_torch
class A_					:




   def __init__(self	:Any    ,   _UpperCamelCase	:List[str]    ,   _UpperCamelCase	:List[Any]=99    ,   _UpperCamelCase	:Optional[int]=13    ,   _UpperCamelCase	:Optional[Any]=16    ,   _UpperCamelCase	:List[str]=7    ,   _UpperCamelCase	:Union[str, Any]=True    ,   _UpperCamelCase	:Dict=True    ,   _UpperCamelCase	:int=True    ,   _UpperCamelCase	:Optional[Any]=False    ,   _UpperCamelCase	:List[str]=True    ,   _UpperCamelCase	:Union[str, Any]=2    ,   _UpperCamelCase	:Dict=32    ,   _UpperCamelCase	:Optional[Any]=4    ,   _UpperCamelCase	:Dict=4    ,   _UpperCamelCase	:Any=30    ,   _UpperCamelCase	:Optional[int]=0    ,   _UpperCamelCase	:Union[str, Any]=1    ,   _UpperCamelCase	:Union[str, Any]=2    ,   _UpperCamelCase	:List[Any]=None    ,   )->					Dict:
         __A          =				parent
         __A          =				batch_size
         __A          =				decoder_seq_length
         # For common tests
         __A          =				self.decoder_seq_length
         __A          =				is_training
         __A          =				use_attention_mask
         __A          =				use_labels

         __A          =				vocab_size
         __A          =				d_model
         __A          =				d_model
         __A          =				decoder_layers
         __A          =				decoder_layers
         __A          =				decoder_ffn_dim
         __A          =				decoder_attention_heads
         __A          =				decoder_attention_heads
         __A          =				eos_token_id
         __A          =				bos_token_id
         __A          =				pad_token_id
         __A          =				decoder_start_token_id
         __A          =				use_cache
         __A          =				max_position_embeddings

         __A          =				None
         __A          =				decoder_seq_length
         __A          =				2
         __A          =				1




   def _lowerCAmelCase      (self	:int )->					Any:
         __A          =				ids_tensor([self.batch_size, self.decoder_seq_length]    ,   self.vocab_size )

         __A          =				None
         if self.use_attention_mask:
               __A          =				ids_tensor([self.batch_size, self.decoder_seq_length]    ,   vocab_size=2 )

         __A          =				None
         if self.use_labels:
               __A          =				ids_tensor([self.batch_size, self.decoder_seq_length]    ,   self.vocab_size )

         __A          =				TrOCRConfig(
             vocab_size=self.vocab_size    ,   d_model=self.d_model    ,   decoder_layers=self.decoder_layers    ,   decoder_ffn_dim=self.decoder_ffn_dim    ,   decoder_attention_heads=self.decoder_attention_heads    ,   eos_token_id=self.eos_token_id    ,   bos_token_id=self.bos_token_id    ,   use_cache=self.use_cache    ,   pad_token_id=self.pad_token_id    ,   decoder_start_token_id=self.decoder_start_token_id    ,   max_position_embeddings=self.max_position_embeddings    ,   )

         return (config, input_ids, attention_mask, lm_labels)




   def _lowerCAmelCase      (self	:Tuple    ,   _UpperCamelCase	:Optional[Any]    ,   _UpperCamelCase	:List[str]    ,   _UpperCamelCase	:Tuple    ,   _UpperCamelCase	:Optional[Any]    ,   )->					str:
         __A          =				True
         __A          =				TrOCRDecoder(config=_UpperCamelCase ).to(_UpperCamelCase ).eval()
         __A          =				input_ids[:2]

         input_ids[input_ids == 0] += 1
         # first forward pass
         __A          =				model(_UpperCamelCase    ,   use_cache=_UpperCamelCase )
         __A          =				model(_UpperCamelCase )
         __A          =				model(_UpperCamelCase    ,   use_cache=_UpperCamelCase )

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

         __A          =				outputs['''past_key_values''']

         # create hypothetical next token and extent to next_input_ids
         __A          =				ids_tensor((2, 1)    ,   config.vocab_size - 1 ) + 1

         # append to next input_ids and
         __A          =				torch.cat([input_ids, next_tokens]    ,   dim=-1 )

         __A          =				model(_UpperCamelCase )['''last_hidden_state''']
         __A          =				model(_UpperCamelCase    ,   past_key_values=_UpperCamelCase )['''last_hidden_state''']

         # select random slice
         __A          =				ids_tensor((1,)    ,   output_from_past.shape[-1] ).item()
         __A          =				output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
         __A          =				output_from_past[:, 0, random_slice_idx].detach()

         # test that outputs are equal for slice
         assert torch.allclose(_UpperCamelCase    ,   _UpperCamelCase    ,   atol=1e-3 )






   def _lowerCAmelCase      (self	:Any )->					Union[str, Any]:
         __A          =				self.prepare_config_and_inputs()
         __A   ,						__A   ,						__A   ,						__A          =				config_and_inputs

         __A          =				{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
         return config, inputs_dict





@require_torch
class A_					(			_lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase ,      unittest.TestCase   ):
   lowerCAmelCase__        = (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
   lowerCAmelCase__        = (TrOCRForCausalLM,) if is_torch_available() else ()
   lowerCAmelCase__        = {"""text-generation""": TrOCRForCausalLM} if is_torch_available() else {}
   lowerCAmelCase__        = True
   lowerCAmelCase__        = False




   def _lowerCAmelCase      (self	:Optional[Any] )->					Optional[int]:
         __A          =				TrOCRStandaloneDecoderModelTester(self    ,   is_training=_UpperCamelCase )
         __A          =				ConfigTester(self    ,   config_class=_UpperCamelCase )




   def _lowerCAmelCase      (self	:Optional[Any] )->					Tuple:
         pass




   def _lowerCAmelCase      (self	:Any )->					List[Any]:
         pass




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




   def _lowerCAmelCase      (self	:Tuple )->					int:
         self.config_tester.run_common_tests()




   def _lowerCAmelCase      (self	:Dict )->					Optional[Any]:
         __A          =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_decoder_model_past(*_UpperCamelCase )




   def _lowerCAmelCase      (self	:Dict )->					Optional[int]:
         return






   @unittest.skip('''The model doesn\'t support left padding''' )  # and it's not used enough to be worth fixing :)
   def _lowerCAmelCase      (self	:List[str] )->					Union[str, Any]:
         pass












import requests

snake_case__					:							int													=     'https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey='



def _a				(	lowerCamelCase:   str )	->						None:







      '''simple docstring'''






      __A          =				requests.get(_NEWS_API + bbc_news_api_key ).json()
      # each article in the list is a dict
      for i, article in enumerate(bbc_news_page['''articles''']					,				1 ):
            print(F"""{i}.) {article['title']}""" )


if __name__ == "__main__":
       fetch_bbc_news(bbc_news_api_key='<Your BBC News API key goes here>')





