'''simple docstring'''

from typing import Any



class 			UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self	,   __lowerCAmelCase )  ->  List[Any]:
        lowercase__				:    Union[str, Any]  =					data
        lowercase__				:    Optional[int]  =					None


       def __repr__(						self )  ->  str:
        return F"""Node({self.data})"""



class 			UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self )  ->  List[Any]:
        lowercase__				:    Union[str, Any]  =					None

       def __iter__(						self )  ->  Any:
        lowercase__				:    List[Any]  =					self.head
        while node:
         yield node.data
         lowercase__				:    Union[str, Any]  =					node.next

       def __len__(						self )  ->  int:
        return sum(1 for _ in self )

       def __repr__(						self )  ->  str:
        return "->".join([str(__lowerCAmelCase ) for item in self] )

       def __getitem__(						self	,   __lowerCAmelCase )  ->  Any:
        if not 0 <= index < len(self ):
         raise ValueError('''list index out of range.''' )
        for i, node in enumerate(self ):
         if i == index:
          return node
        return None

       def __setitem__(						self	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  None:
        if not 0 <= index < len(self ):
         raise ValueError('''list index out of range.''' )
        lowercase__				:    str  =					self.head
        for _ in range(__lowerCAmelCase ):
         lowercase__				:    Dict  =					current.next
        lowercase__				:    Union[str, Any]  =					data

       def _lowerCAmelCase(						self	,   __lowerCAmelCase )  ->  None:
        self.insert_nth(len(self )	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase )  ->  None:
        self.insert_nth(0	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  None:
        if not 0 <= index <= len(self ):
         raise IndexError('''list index out of range''' )
        lowercase__				:    List[Any]  =					Node(__lowerCAmelCase )
        if self.head is None:
         lowercase__				:    Any  =					new_node
        elif index == 0:
         lowercase__				:    Union[str, Any]  =					self.head  # link new_node to head
         lowercase__				:    Any  =					new_node
        else:
         lowercase__				:    Optional[Any]  =					self.head
         for _ in range(index - 1 ):
          lowercase__				:    Optional[int]  =					temp.next
         lowercase__				:    Tuple  =					temp.next
         lowercase__				:    str  =					new_node

       def _lowerCAmelCase(						self )  ->  None:  # print every node data
        print(self )

       def _lowerCAmelCase(						self )  ->  Any:
        return self.delete_nth(0 )

       def _lowerCAmelCase(						self )  ->  Any:  # delete from tail
        return self.delete_nth(len(self ) - 1 )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase = 0 )  ->  Any:
        if not 0 <= index <= len(self ) - 1:  # test if index is valid
         raise IndexError('''List index out of range.''' )
        lowercase__				:    Any  =					self.head  # default first node
        if index == 0:
         lowercase__				:    Dict  =					self.head.next
        else:
         lowercase__				:    str  =					self.head
         for _ in range(index - 1 ):
          lowercase__				:    Union[str, Any]  =					temp.next
         lowercase__				:    Optional[int]  =					temp.next
         lowercase__				:    List[str]  =					temp.next.next
        return delete_node.data

       def _lowerCAmelCase(						self )  ->  bool:
        return self.head is None


       def _lowerCAmelCase(						self )  ->  None:
        lowercase__				:    Any  =					None
        lowercase__				:    Tuple  =					self.head

        while current:
         # Store the current node's next node.
         lowercase__				:    str  =					current.next
         # Make the current node's next point backwards
         lowercase__				:    List[Any]  =					prev
         # Make the previous node be the current node
         lowercase__				:    int  =					current
         # Make the current node the next node (to progress iteration)
         lowercase__				:    List[Any]  =					next_node
        # Return prev in order to put the head at the end
        lowercase__				:    Optional[Any]  =					prev


def 			__UpperCamelCase       (   ):
 lowercase__				:    str  =					LinkedList()
 assert linked_list.is_empty() is True
 assert str(UpperCAmelCase     ) == ""

 try:
  linked_list.delete_head()
  raise AssertionError  # This should not happen.
 except IndexError:
  assert True  # This should happen.

 try:
  linked_list.delete_tail()
  raise AssertionError  # This should not happen.
 except IndexError:
  assert True  # This should happen.

 for i in range(10     ):
  assert len(UpperCAmelCase     ) == i
  linked_list.insert_nth(UpperCAmelCase		,     i + 1     )
 assert str(UpperCAmelCase     ) == "->".join(str(UpperCAmelCase     ) for i in range(1		,     11     )     )

 linked_list.insert_head(0     )
 linked_list.insert_tail(11     )
 assert str(UpperCAmelCase     ) == "->".join(str(UpperCAmelCase     ) for i in range(0		,     12     )     )

 assert linked_list.delete_head() == 0
 assert linked_list.delete_nth(9     ) == 10
 assert linked_list.delete_tail() == 11
 assert len(UpperCAmelCase     ) == 9
 assert str(UpperCAmelCase     ) == "->".join(str(UpperCAmelCase     ) for i in range(1		,     10     )     )

 assert all(linked_list[i] == i + 1 for i in range(0		,     9     )     ) is True

 for i in range(0		,     9     ):
  lowercase__				:    Optional[Any]  =					-i
 assert all(linked_list[i] == -i for i in range(0		,     9     )     ) is True

 linked_list.reverse()
 assert str(UpperCAmelCase     ) == "->".join(str(UpperCAmelCase     ) for i in range(-8		,     1     )     )
def 			__UpperCamelCase       (   ):
 lowercase__				:    List[str]  =					[
     -9,
     100,
     Node(7734_5112     ),
     '''dlrow olleH''',
     7,
     5555,
     0,
     -1_9_2.5_5_5_5_5,
     '''Hello, world!''',
     7_7.9,
     Node(10     ),
     None,
     None,
     1_2.2_0,
 ]
 lowercase__				:    Optional[int]  =					LinkedList()

 for i in test_input:
  linked_list.insert_tail(UpperCAmelCase     )

 # Check if it's empty or not
 assert linked_list.is_empty() is False
 assert (
     str(UpperCAmelCase     ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
     "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
 )

 # Delete the head
 lowercase__				:    Union[str, Any]  =					linked_list.delete_head()
 assert result == -9
 assert (
     str(UpperCAmelCase     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None->None->12.2"
 )

 # Delete the tail
 lowercase__				:    Union[str, Any]  =					linked_list.delete_tail()
 assert result == 1_2.2
 assert (
     str(UpperCAmelCase     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None->None"
 )

 # Delete a node in specific location in linked list
 lowercase__				:    List[str]  =					linked_list.delete_nth(10     )
 assert result is None
 assert (
     str(UpperCAmelCase     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None"
 )

 # Add a Node instance to its head
 linked_list.insert_head(Node('''Hello again, world!'''     )     )
 assert (
     str(UpperCAmelCase     )
     == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
     "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
 )

 # Add None to its tail
 linked_list.insert_tail(UpperCAmelCase     )
 assert (
     str(UpperCAmelCase     )
     == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
     "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
 )

 # Reverse the linked list
 linked_list.reverse()
 assert (
     str(UpperCAmelCase     )
     == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
     "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
 )
def 			__UpperCamelCase       (   ):
 from doctest import testmod

 testmod()

 lowercase__				:    Tuple  =					LinkedList()
 linked_list.insert_head(input('''Inserting 1st at head '''     ).strip()     )
 linked_list.insert_head(input('''Inserting 2nd at head '''     ).strip()     )
 print('''\nPrint list:'''     )
 linked_list.print_list()
 linked_list.insert_tail(input('''\nInserting 1st at tail '''     ).strip()     )
 linked_list.insert_tail(input('''Inserting 2nd at tail '''     ).strip()     )
 print('''\nPrint list:'''     )
 linked_list.print_list()
 print('''\nDelete head'''     )
 linked_list.delete_head()
 print('''Delete tail'''     )
 linked_list.delete_tail()
 print('''\nPrint list:'''     )
 linked_list.print_list()
 print('''\nReverse linked list'''     )
 linked_list.reverse()
 print('''\nPrint list:'''     )
 linked_list.print_list()
 print('''\nString representation of linked list:'''     )
 print(UpperCAmelCase     )
 print('''\nReading/changing Node data using indexing:'''     )
 print(F"""Element at Position 1: {linked_list[1]}"""     )
 lowercase__				:    int  =					input('''Enter New Value: '''     ).strip()
 print('''New list:'''     )
 print(UpperCAmelCase     )
 print(F"""length of linked_list is : {len(UpperCAmelCase     )}"""     )


if __name__ == "__main__":
  main()


'''simple docstring'''

import requests

__a: str          =   """https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="""
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 # fetching a list of articles in json format
 lowercase__				:    Optional[Any]  =					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>""")

