





'''simple docstring'''







from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from typing import Any



class 							__SCREAMING_SNAKE_CASE			:
      '''simple docstring'''



      lowerCAmelCase__       :      Tuple 		=		('_front', '_back', '_len')



      @dataclass
      class 							__SCREAMING_SNAKE_CASE			:
            '''simple docstring'''



            lowerCAmelCase__       :      Any 		=		None
            lowerCAmelCase__       :      Deque._Node | None 		=		None
            lowerCAmelCase__       :      Deque._Node | None 		=		None



      class 							__SCREAMING_SNAKE_CASE			:
            '''simple docstring'''



            lowerCAmelCase__       :      Dict 		=		('_cur',)

            def __init__(							self    : List[str]   ,UpperCamelCase    : Deque._Node | None  )		->  None:
                 _lowercase							:      Tuple  						=							cur

            def __iter__(							self    : List[str]  )		->  Deque._Iterator:
                 return self



            def   _lowerCamelCase		(							self    : Tuple  )		->  Any:
                 if self._cur is None:
                      # finished iterating
                      raise StopIteration
                 _lowercase							:      Any  						=							self._cur.val
                 _lowercase							:      List[Any]  						=							self._cur.next_node

                 return val

      def __init__(							self    : Tuple   ,UpperCamelCase    : Iterable[Any] | None = None  )		->  None:
           _lowercase							:      List[Any]  						=							None
           _lowercase							:      str  						=							None
           _lowercase							:      List[str]  						=							0

           if iterable is not None:
                # append every value to the deque
                for val in iterable:
                     self.append(UpperCamelCase  )

      def   _lowerCamelCase		(							self    : Union[str, Any]   ,UpperCamelCase    : Any  )		->  None:
           _lowercase							:      Tuple  						=							self._Node(UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase  )
           if self.is_empty():
                # front = back
                _lowercase							:      List[Any]  						=							node
                _lowercase							:      Any  						=							1
           else:
                # connect nodes
                _lowercase							:      str  						=							node
                _lowercase							:      Any  						=							self._back
                _lowercase							:      List[Any]  						=							node  # assign new back to the new node

                self._len += 1

                # make sure there were no errors
                assert not self.is_empty(), "Error on appending value."

      def   _lowerCamelCase		(							self    : Optional[Any]   ,UpperCamelCase    : Any  )		->  None:
           _lowercase							:      List[Any]  						=							self._Node(UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase  )
           if self.is_empty():
                # front = back
                _lowercase							:      Optional[Any]  						=							node
                _lowercase							:      int  						=							1
           else:
                # connect nodes
                _lowercase							:      Union[str, Any]  						=							self._front
                _lowercase							:      Any  						=							node
                _lowercase							:      List[str]  						=							node  # assign new front to the new node

                self._len += 1

                # make sure there were no errors
                assert not self.is_empty(), "Error on appending value."

      def   _lowerCamelCase		(							self    : str   ,UpperCamelCase    : Iterable[Any]  )		->  None:
           for val in iterable:
                self.append(UpperCamelCase  )

      def   _lowerCamelCase		(							self    : Tuple   ,UpperCamelCase    : Iterable[Any]  )		->  None:
           for val in iterable:
                self.appendleft(UpperCamelCase  )

      def   _lowerCamelCase		(							self    : Dict  )		->  Any:
           assert not self.is_empty(), "Deque is empty."

           _lowercase							:      List[Any]  						=							self._back
           _lowercase							:      Tuple  						=							self._back.prev_node  # set new back
           # drop the last node - python will deallocate memory automatically
           _lowercase							:      str  						=							None

           self._len -= 1

           return topop.val

      def   _lowerCamelCase		(							self    : List[Any]  )		->  Any:
           assert not self.is_empty(), "Deque is empty."

           _lowercase							:      Optional[Any]  						=							self._front
           _lowercase							:      List[Any]  						=							self._front.next_node  # set new front and drop the first node
           _lowercase							:      Union[str, Any]  						=							None

           self._len -= 1

           return topop.val

      def   _lowerCamelCase		(							self    : int  )		->  bool:
           return self._front is None

      def __len__(							self    : Dict  )		->  int:
           return self._len

      def __eq__(							self    : str   ,UpperCamelCase    : object  )		->  bool:

           if not isinstance(UpperCamelCase   ,UpperCamelCase  ):
                return NotImplemented

           _lowercase							:      Union[str, Any]  						=							self._front
           _lowercase							:      Union[str, Any]  						=							other._front

           # if the length of the dequeues are not the same, they are not equal
           if len(self  ) != len(UpperCamelCase  ):
                return False

           while me is not None and oth is not None:
                # compare every value
                if me.val != oth.val:
                     return False
                _lowercase							:      Optional[int]  						=							me.next_node
                _lowercase							:      int  						=							oth.next_node

           return True

      def __iter__(							self    : Optional[Any]  )		->  Deque._Iterator:
           return Deque._Iterator(self._front  )



      def __repr__(							self    : List[Any]  )		->  str:
           _lowercase							:      str  						=							[]
           _lowercase							:      Union[str, Any]  						=							self._front
           while aux is not None:
                # append the values in a list to display
                values_list.append(aux.val  )
                _lowercase							:      Union[str, Any]  						=							aux.next_node

           return F'''[{', '.join(repr(UpperCamelCase  ) for val in values_list  )}]'''


if __name__ == "__main__":
    import doctest

    doctest.testmod()






'''simple docstring'''







import requests
from bsa import BeautifulSoup

def 		SCREAMING_SNAKE_CASE      (					lowerCAmelCase__     :	int       ,  lowerCAmelCase__     :	str)			->						str:

     '''simple docstring'''




     _lowercase							:      int  						=							(
         'https://www.horoscope.com/us/horoscopes/general/'
         F'''horoscope-general-daily-{day}.aspx?sign={zodiac_sign}'''
     )
     _lowercase							:      Any  						=							BeautifulSoup(requests.get(lowerCAmelCase__).content       ,  'html.parser')
     return soup.find('div'       ,  class_='main-horoscope').p.text


if __name__ == "__main__":
    print('''Daily Horoscope. \n''')
    print(
        '''enter your Zodiac sign number:\n''',
        '''1. Aries\n''',
        '''2. Taurus\n''',
        '''3. Gemini\n''',
        '''4. Cancer\n''',
        '''5. Leo\n''',
        '''6. Virgo\n''',
        '''7. Libra\n''',
        '''8. Scorpio\n''',
        '''9. Sagittarius\n''',
        '''10. Capricorn\n''',
        '''11. Aquarius\n''',
        '''12. Pisces\n''',
    )
    A						    =							int(input('''number> ''').strip())
    print('''choose some day:\n''', '''yesterday\n''', '''today\n''', '''tomorrow\n''')
    A						    =							input('''enter the day> ''')
    A						    =							horoscope(zodiac_sign, day)
    print(horoscope_text)