


'''simple docstring'''




import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar







class 					a			(				unittest.TestCase  ):
 '''simple docstring'''




 def   __UpperCamelCase   (    self      )      ->    Dict:
    _a					:  Any						=  logging.get_logger()

    # the current default level is logging.WARNING
    _a					:  Union[str, Any]						=  logging.get_verbosity()

    logging.set_verbosity_error()
    self.assertEqual(logger.getEffectiveLevel()		,      logging.get_verbosity()      )

    logging.set_verbosity_warning()
    self.assertEqual(logger.getEffectiveLevel()		,      logging.get_verbosity()      )

    logging.set_verbosity_info()
    self.assertEqual(logger.getEffectiveLevel()		,      logging.get_verbosity()      )

    logging.set_verbosity_debug()
    self.assertEqual(logger.getEffectiveLevel()		,      logging.get_verbosity()      )

    # restore to the original level
    logging.set_verbosity(lowerCamelCase_      )




 def   __UpperCamelCase   (    self      )      ->    Optional[int]:
    _a					:  Optional[Any]						=  logging.get_verbosity()

    _a					:  Tuple						=  logging.get_logger('transformers.models.bart.tokenization_bart'      )
    _a					:  Any						=  'Testing 1, 2, 3'

    # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
    if level_origin <= logging.WARNING:
       with CaptureLogger(lowerCamelCase_      ) as cl:
          logger.warning(lowerCamelCase_      )
       self.assertEqual(cl.out		,      msg + '\n'      )

    # this is setting the level for all of `transformers.*` loggers
    logging.set_verbosity_error()

    # should not be able to log warnings
    with CaptureLogger(lowerCamelCase_      ) as cl:
       logger.warning(lowerCamelCase_      )
    self.assertEqual(cl.out		,      ''      )

    # should be able to log warnings again
    logging.set_verbosity_warning()
    with CaptureLogger(lowerCamelCase_      ) as cl:
       logger.warning(lowerCamelCase_      )
    self.assertEqual(cl.out		,      msg + '\n'      )

    # restore to the original level
    logging.set_verbosity(lowerCamelCase_      )




 @mockenv(TRANSFORMERS_VERBOSITY='error'      )
 def   __UpperCamelCase   (    self      )      ->    Optional[int]:
    # reset for the env var to take effect, next time some logger call is made
    transformers.utils.logging._reset_library_root_logger()
    # this action activates the env var
    _a					:  int						=  logging.get_logger('transformers.models.bart.tokenization_bart'      )

    _a					:  Any						=  os.getenv('TRANSFORMERS_VERBOSITY'		,      lowerCamelCase_      )
    _a					:  Optional[int]						=  logging.log_levels[env_level_str]

    _a					:  Optional[int]						=  logging.get_verbosity()
    self.assertEqual(
        lowerCamelCase_		,      lowerCamelCase_		,      F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''		,      )

    # restore to the original level
    _a					:  Tuple						=  ''
    transformers.utils.logging._reset_library_root_logger()




 @mockenv(TRANSFORMERS_VERBOSITY='super-error'      )
 def   __UpperCamelCase   (    self      )      ->    Optional[int]:
    # reset for the env var to take effect, next time some logger call is made
    transformers.utils.logging._reset_library_root_logger()
    _a					:  Optional[int]						=  logging.logging.getLogger()
    with CaptureLogger(lowerCamelCase_      ) as cl:
       # this action activates the env var
       logging.get_logger('transformers.models.bart.tokenization_bart'      )
    self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error'		,      cl.out      )

    # no need to restore as nothing was changed




 def   __UpperCamelCase   (    self      )      ->    int:
    # testing `logger.warning_advice()`
    transformers.utils.logging._reset_library_root_logger()

    _a					:  int						=  logging.get_logger('transformers.models.bart.tokenization_bart'      )
    _a					:  Union[str, Any]						=  'Testing 1, 2, 3'

    with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1'      ):
       # nothing should be logged as env var disables this method
       with CaptureLogger(lowerCamelCase_      ) as cl:
          logger.warning_advice(lowerCamelCase_      )
       self.assertEqual(cl.out		,      ''      )

    with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''      ):
       # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
       with CaptureLogger(lowerCamelCase_      ) as cl:
          logger.warning_advice(lowerCamelCase_      )
       self.assertEqual(cl.out		,      msg + '\n'      )





def    UpperCAmelCase_  (       ):
   '''simple docstring'''





   disable_progress_bar()
   assert are_progress_bars_disabled()

   enable_progress_bar()
   assert not are_progress_bars_disabled()






'''simple docstring'''




import requests
from bsa import BeautifulSoup


def    UpperCAmelCase_  (       A = "https://www.worldometers.info/coronavirus"      ):
   '''simple docstring'''





   _a					:  Union[str, Any]						=  BeautifulSoup(requests.get(A      ).text		,	'html.parser'      )
   _a					:  int						=  soup.findAll('h1'      )
   _a					:  Union[str, Any]						=  soup.findAll('div'		,	{'class': 'maincounter-number'}      )
   keys += soup.findAll('span'		,	{'class': 'panel-title'}      )
   values += soup.findAll('div'		,	{'class': 'number-table-main'}      )
   return {key.text.strip(): value.text.strip() for key, value in zip(A		,	A      )}


if __name__ == "__main__":
 print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
 for key, value in world_covidaa_stats().items():
  print(f'''{key}\n{value}\n''')


